void
hexdump(FILE *f, int indent, const char *p, int len)
{
const unsigned char *cp = (const unsigned char *)p;
char hex[16 * 3 + 1], *hp, ascii[16 + 1], *ap;
int i, c;
while (len) {
hp = hex;
ap = ascii;
for (i = 0; len && i < 16; i++) {
c = *cp++;
len--;
hp += sprintf(hp, "%02x ", c);
*ap++ = c < 127 && c >= 32 ? c : '.';
}
*ap = 0;
fprintf(f, "%s%-48s |%-16s|\n", pad(indent), hex, ascii);
}
}
void printObject(Object* obj, int indent) {
switch (obj->kind) {
case OBJ_CONSTANT:
pad(indent);
printf("Const %s = ", obj->name);
printConstantValue(obj->constAttrs->value);
break;
case OBJ_TYPE:
pad(indent);
printf("Type %s = ", obj->name);
printType(obj->typeAttrs->actualType);
break;
case OBJ_VARIABLE:
pad(indent);
printf("Var %s : ", obj->name);
printType(obj->varAttrs->type);
break;
case OBJ_PARAMETER:
pad(indent);
if (obj->paramAttrs->kind == PARAM_VALUE)
printf("Param %s : ", obj->name);
else
printf("Param VAR %s : ", obj->name);
printType(obj->paramAttrs->type);
break;
case OBJ_FUNCTION:
pad(indent);
printf("Function %s : ", obj->name);
printType(obj->funcAttrs->returnType);
printf("\n");
printScope(obj->funcAttrs->scope, indent + 4);
break;
case OBJ_PROCEDURE:
pad(indent);
printf("Procedure %s\n", obj->name);
printScope(obj->procAttrs->scope, indent + 4);
break;
case OBJ_PROGRAM:
pad(indent);
printf("Program %s\n", obj->name);
printScope(obj->progAttrs->scope, indent + 4);
break;
}
}
static void encode_sequence(const char *plain, int len, char *coded) {
assert(len >= 0 && len <= 5);
for (int block = 0; block < 8; block++) {
int octet = get_octet(block);
int junk = get_offset(block);
if (octet >= len) {
pad(&coded[block], 8 - block);
return;
}
char c = shift_right(plain[octet], junk);
if (junk < 0 && octet < len - 1) {
c |= shift_right(plain[octet+1], 8 + junk);
}
coded[block] = encode_char(c);
}
}
void vcat_pic::display(std::ostream &os, ht_sz row, bool do_pad) const
{
wd_sz w = 0;
if(row < top->height())
{
// we are in the top subpicture
top->display(os,row,do_pad);
w = top->width();
}
else if(row < height())
{
// we are in the bottom subpicture
bottom->display(os,row-top->height(),do_pad);
w = bottom->width();
}
if(do_pad)
{
pad(os,w,width());
}
}
void putop(int op)
{
int i;
int seg;
i = 0;
while( opl[i].s )
{
if( opl[i].ov == (op & 255))
{
//seg = op & 0xFF00;
//if (seg != 0) {
// fprintf(output, "%s:", segstr(op));
//}
ofs.write(pad(opl[i].s));
return;
}
++i;
}
printf("DIAG - illegal opcode.\n");
}
void* IATModifier::allocateMemAboveBase(void* baseAddress, size_t size) {
try {
MEMORY_BASIC_INFORMATION mbi;
for (char* currentAddress = (char*)baseAddress;; currentAddress = (char*)mbi.BaseAddress + mbi.RegionSize) {
mbi = process_.queryMemory(currentAddress);
if (mbi.State != MEM_FREE) continue;
// Walk memory region in allocation granularity steps.
char* bruteForce = (char*)pad((unsigned int)currentAddress, 0xFFFF);
while (bruteForce < (char*)mbi.BaseAddress + mbi.RegionSize) {
try {
process_.allocMem(size, bruteForce, MEM_RESERVE | MEM_COMMIT);
return bruteForce;
}catch (MemoryAllocationException) {
}
bruteForce += 0x10000;
}
}
} catch (const MemoryQueryException&) {
return NULL;
}
}
void write_bmp(const BMP<DIB, I, D>& bmp, std::ostream& os)
{
typedef typename BMP<DIB, I, D>::color_type C;
unsigned int l = bmp.dib_h.width * (bmp.dib_h.bpp / 8);
unsigned int rowsize = ((bmp.dib_h.bpp * bmp.dib_h.width + 31) / 32) * 4;
std::vector<D> buf(bmp.dib_h.width);
std::vector<std::uint8_t> pad(rowsize - l);
I i(bmp.iter);
os << aux::write_to(bmp.bmp_h);
os << aux::write_to(bmp.dib_h);
for(int h = 0 ; h < bmp.dib_h.height ; ++h)
{
aux::transform_n(i, bmp.dib_h.width, buf.begin(), [](const C& c) { return static_cast<D>(c); });
os << aux::write_to(*buf.begin(), l);
os << aux::write_to(*pad.begin(), pad.size());
}
}
/* emit_value - emits an initialization for the type given by ty */
static int emit_value(int lc, Type ty, ...) {
Value v;
va_list ap;
va_start(ap, ty);
if (lc == 0)
maxalign = 0;
lc = pad(ty->align, lc);
switch (ty->op) {
case INT: v.i = va_arg(ap, long); break;
case UNSIGNED: v.u = va_arg(ap, unsigned long); break;
case FLOAT: v.d = va_arg(ap, long double); break;
case POINTER:
defpointer(va_arg(ap, Symbol));
return lc + ty->size;
default: assert(0);
}
va_end(ap);
(*IR->defconst)(ty->op, ty->size, v);
return lc + ty->size;
}
void dumpregs(struct TrapData *td)
{ int i;
XIOdebug("Registers dump:\n");
XIOdebug("Trapdata is at %X\n",(int)td);
for( i = 0; i< 32; i+=4)
{ int j;
for( j = i; j < i+4; j++)
{ char * f;
int fwidth;
f = j< 10? "r%d = %X":"r%d = %X";
fwidth = XIOdebug(f,j,td->intregs[j]);
pad(17,fwidth);
}
XIOdebug("\n");
}
XIOdebug("psr = %X\n",td->PSR);
XIOdebug("db = %X\n",td->DB);
XIOdebug("dirbase = %X\n",td->DIRBASE);
XIOdebug("fir = %X\n",td->FIR);
XIOdebug("fsr = %X\n",td->FSR);
}
void
elf32DumpDynamic(FILE *f, const Elf32_Dyn *dyn, int indent)
{
const char *padding = pad(indent);
static const char *tagNames[] = {
"DT_NULL",
"DT_NEEDED",
"DT_PLTRELSZ",
"DT_PLTGOT",
"DT_HASH",
"DT_STRTAB",
"DT_SYMTAB",
"DT_RELA",
"DT_RELASZ",
"DT_RELAENT",
"DT_STRSZ",
"DT_SYMENT",
"DT_INIT",
"DT_FINI",
"DT_SONAME",
"DT_RPATH",
"DT_SYMBOLIC",
"DT_REL",
"DT_RELSZ",
"DT_RELENT",
"DT_PLTREL",
"DT_DEBUG",
"DT_TEXTREL",
"DT_JMPREL",
"DT_BIND_NOW"
};
#ifndef DT_COUNT
#define DT_COUNT (sizeof tagNames / sizeof tagNames[0])
#endif
fprintf(f, "%stag: %d (%s)\n", padding, dyn->d_tag,
dyn->d_tag >= 0 && dyn->d_tag <= DT_COUNT ?
tagNames[dyn->d_tag] : "(unknown)");
fprintf(f, "%sword/addr: %d (%x)\n",
padding, dyn->d_un.d_val, dyn->d_un.d_val);
}
void putop(Instruction *insn,int op, int len)
{
int i;
char buf[100];
i = 0;
// while( opl[i].mnem )
// {
// if( opl[i].opcode == (op & 0x1FF))
// {
//seg = op & 0xFF00;
//if (seg != 0) {
// fprintf(output, "%s:", segstr(op));
//}
if (len) {
if (len <= 16) {
switch(len) {
case 1: sprintf_s(buf, sizeof(buf), "%s.b", insn->mnem); break;
case 2: sprintf_s(buf, sizeof(buf), "%s.c", insn->mnem); break;
case 4: sprintf_s(buf, sizeof(buf), "%s.h", insn->mnem); break;
case 8: sprintf_s(buf, sizeof(buf), "%s", insn->mnem); break;
}
}
else {
if (len != 'w' && len!='W')
sprintf_s(buf, sizeof(buf), "%s.%c", insn->mnem, len);
else
sprintf_s(buf, sizeof(buf), "%s", insn->mnem);
}
}
else
sprintf_s(buf, sizeof(buf), "%s", insn->mnem);
ofs.write(pad(buf));
return;
// }
// ++i;
// }
printf("DIAG - illegal opcode (%d).\n", op);
}
void printEntries(std::ostream &o, const std::vector<Entry *> &entries, const std::string &indent, double parent_time) {
if (parent_time <= 0.0) {
parent_time = 0.0;
for (size_t i = 0; i < entries.size(); ++i) {
parent_time += entries[i]->time;
}
}
double t_tot = 0.0;
for (size_t i = 0; i < entries.size(); ++i) {
const Entry *entry = entries[i];
std::ostringstream r;
r << indent;
std::string str = names[entry->id];
if (str.empty()) {
r << "(" << entry->id << ")";
} else {
r << str;
}
r << " ";
std::string pad(r.str().size(), ' ');
r << " - exectime: " << entry->time << "s (" << (entry->time * 100.0 / parent_time) << "%)" << std::endl;
if (entry->allocTotal || entry->memoryDiff) {
r << pad << " - alloc: " << formatMemory(entry->allocTotal) << " delta: " << formatMemory(entry->memoryDiff) << std::endl;
r << pad << " - alloc blks:";
for (int i = 0; i < 32; i++) { if (entry->delta_blk_cnt_total[i]) r << ' ' << ((1 << (i - 1)) + 1) << '-' << (1 << i) << ':' << entry->delta_blk_cnt_total[i]; }
r << std::endl;
r << pad << " - delta blks:";
for (int i = 0; i < 32; i++) { if (entry->delta_blk_cnt_curr[i]) r << ' ' << ((1 << (i - 1)) + 1) << '-' << (1 << i) << ':' << entry->delta_blk_cnt_curr[i]; }
r << std::endl;
}
o << r.str();
t_tot += entry->time;
if (entry->children.size()) printEntries(o, entry->children, indent + " ", entry->time);
}
if (t_tot < parent_time) {
o << indent << "*** unaccounted: " << (parent_time - t_tot) << "s (" << (100.0 - t_tot * 100.0 / parent_time) << "%)" << std::endl;
}
}
mixed cmd_score(string cmd, string str, object actor){
mapping stats;
int i;
string *attributes;
stats = actor->query_stats();
attributes = map_indices(stats);
i = sizeof(attributes);
str = actor->query_Name() + "\n";
while(i--){
str += "%^BOLD%^%^CYAN%^"+pad(capitalize(attributes[i])+": ", 15)+"%^RESET%^"+stats[attributes[i]]+"\n";
}
#ifdef ASTARIA_CLONE
str += "hp "+actor->query_health()+" / "+actor->query_max_health()+"\n";
#else
str += actor->query_diagram();
#endif
actor->message(str);
return 1;
}
static inline std::string modulePrefix(module_t m, message_t msgType)
{
if(m == MODULES_ALL) {
switch(msgType) {
case MSG_TRACE:
return "[trace] ";
case MSG_DEBUG:
return "[debug] ";
case MSG_INFO:
return "[info] ";
case MSG_WARNING:
return "[warning] ";
case MSG_ERROR:
return "[error] ";
case MSG_FATAL:
return "[fatal] ";
default:
return "[...] ";
}
}
return pad(std::string(1, '[') + moduleToString(m) + "] ");
}
extern void *__construct_new_array(void *block,ConstructorDestructor ctor,ConstructorDestructor dtor,size_t size,size_t n)
{
char *ptr;
if((ptr=(char *)block)!=0L)
{
size_t *p = (size_t *)ptr;
// store number of allocated objects and size of one object at the beginnig of the allocated block
p[0]=size;
p[1]=n;
ptr+=ARRAY_HEADER_SIZE;
if(ctor)
{ // call constructor to initialize array
__partial_array_destructor pad(ptr,size,n,dtor);
char *p;
for(pad.i=0,p=(char *)ptr; pad.i<n; pad.i++,p+=size) CTORCALL_COMPLETE(ctor,p);
}
}
return ptr; // return pointer to first object;
}
void LineBufferCPU(int inH, int inW, int padH, int padW, int kH, int kW, int stride, float *kernel, float *dataIn, float *dataOut){
int paddedH = inH+2*padH;
int paddedW = inW+2*padW;
float *padded = malloc(paddedH*paddedW*sizeof(float));
pad(inH,inW,padH,padW,dataIn,padded);
int outH = (paddedH-kH) + 1;
int outW = (paddedW-kW) + 1;
float **lb = malloc(outH*outW*sizeof(float*));
for (int i=0; i<outH*outW; i++) lb[i] = malloc(kH*kW*sizeof(float));
lineBuffer(paddedH,paddedW,kH,kW,stride,padded,lb);
print_2d_data(padded, "PADDED",paddedH,paddedW);
free(padded);
for (int i=0; i<outH*outW; i++) {
dataOut[i] = 0;
for(int j=0; j<kH*kW;j++) {
dataOut[i] += kernel[j] *lb[i][j];
}
}
for (int i=0; i<outH*outW; i++) free(lb[i]);
free(lb);
}
//-----------------------------------------------------------------------------
ImplicitMesh::ImplicitMesh(SimpleMesh * mesh) : mSourceMesh(mesh), mData(NULL)
{
// Loop through all vertices in the mesh to determine the smallest
// bounding box needed
Vector3<float> pMin((std::numeric_limits<float>::max)(), (std::numeric_limits<float>::max)(), (std::numeric_limits<float>::max)());
Vector3<float> pMax(-(std::numeric_limits<float>::max)(), -(std::numeric_limits<float>::max)(), -(std::numeric_limits<float>::max)());
const std::vector<SimpleMesh::Vertex>& verts = mSourceMesh->GetVerts();
for(unsigned int i=0; i < verts.size(); i++){
const SimpleMesh::Vertex &v = verts.at(i);
for (int j = 0; j < 3; j++) {
if (pMin[j] > v.pos[j]) pMin[j] = v.pos[j];
if (pMax[j] < v.pos[j]) pMax[j] = v.pos[j];
}
}
// Pad with 0.1 to get around border issues
Vector3<float> pad(0.1, 0.1, 0.1);
pMin -= pad;
pMax += pad;
mBox = Bbox(pMin, pMax);
std::cout << "Bounding box of implicit mesh: " << mBox << std::endl;
}
void VCXYPad_Test::copy()
{
QWidget w;
VCFrame parent(&w, m_doc);
VCXYPad pad(&parent, m_doc);
pad.setCaption("Dingdong");
QSize size(80, 80);
QPointF pt(50, 30);
pad.m_area->setPosition(pt);
VCXYPadFixture xyf1(m_doc);
xyf1.setHead(GroupHead(1,5));
pad.appendFixture(xyf1);
VCXYPadFixture xyf2(m_doc);
xyf2.setHead(GroupHead(2,7));
pad.appendFixture(xyf2);
VCXYPadFixture xyf3(m_doc);
xyf3.setHead(GroupHead(3,9));
pad.appendFixture(xyf3);
VCXYPad* copy = qobject_cast<VCXYPad*> (pad.createCopy(&parent));
QVERIFY(copy != NULL);
QCOMPARE(copy->m_fixtures.size(), 3);
QVERIFY(copy->m_fixtures[0] == xyf1);
QVERIFY(copy->m_fixtures[1] == xyf2);
QVERIFY(copy->m_fixtures[2] == xyf3);
QVERIFY(©->m_fixtures[0] != &xyf1);
QVERIFY(©->m_fixtures[1] != &xyf2);
QVERIFY(©->m_fixtures[2] != &xyf3);
QCOMPARE(copy->m_area->position(), pt);
QCOMPARE(copy->size(), pad.size());
QCOMPARE(copy->caption(), QString("Dingdong"));
}
string dsp::PlotFactory::help()
{
unsigned ia, maxlen = 0;
for (ia=0; ia < agents.size(); ia++) {
if (get_name(ia).length() > maxlen) {
maxlen = get_name(ia).length();
}
}
maxlen += 2;
string result;
for (ia=0; ia < agents.size(); ia++) {
result += pad(maxlen, get_name(ia)) +
"[" +
agents[ia]->get_shortcut() +
"] " +
get_description(ia) +
"\n";
}
return result;
}
/*---------------------------------------------------------------------------*/
static int
create_and_secure(void)
{
struct hdr *chdr;
int hdr_len;
hdr_len = create();
if(hdr_len < 0) {
return FRAMER_FAILED;
}
packetbuf_compact();
if(!NETSTACK_LLSEC.on_frame_created()) {
PRINTF("contikimac-framer: securing failed\n");
return FRAMER_FAILED;
}
chdr = (struct hdr *)(((uint8_t *) packetbuf_dataptr()) - sizeof(struct hdr));
chdr->len = packetbuf_datalen();
pad();
return hdr_len;
}
/* print_text_node -- convert given node to plain text and append */
void print_text_node(GString *out, node *n, scratch_pad *scratch) {
switch (n->key) {
case STR:
g_string_append_printf(out,"%s",n->str);
break;
case METADATA:
print_text_node_tree(out,n->children,scratch);
break;
case METAKEY:
g_string_append_printf(out,"%s:\t",n->str);
print_text_node(out,n->children,scratch);
break;
case METAVALUE:
g_string_append_printf(out,"%s",n->str);
pad(out,1, scratch);
break;
case FOOTER:
break;
default:
fprintf(stderr, "print_text_node encountered unknown node key = %d\n",n->key);
exit(EXIT_FAILURE);
}
}
/*---------------------------------------------------------------------------*/
static int
create(void)
{
struct hdr *chdr;
int hdr_len;
if(packetbuf_hdralloc(sizeof(struct hdr)) == 0) {
PRINTF("contikimac-framer: too large header\n");
return FRAMER_FAILED;
}
chdr = packetbuf_hdrptr();
chdr->id = CONTIKIMAC_ID;
chdr->len = packetbuf_datalen();
pad();
hdr_len = DECORATED_FRAMER.create();
if(hdr_len < 0) {
PRINTF("contikimac-framer: decorated framer failed\n");
return FRAMER_FAILED;
}
return hdr_len + sizeof(struct hdr);
}
// NOTE: It works surprisingly well
int main() {
mpz_class totalSum = 0;
for (int d = 0; d < 10; ++d)
for (int m = N - 1; m >= 1; --m) {
mpz_class sumOfPrimes = 0;
mpz_class numberOfPrimes = 0;
std::string pad(m, '0' + d);
std::string pattern;
if (d == 0) pattern.append(N - m, '1');
else pattern.append(N - m, '0');
do {
int i = 1;
while (i < pattern.size() && pattern[i] >= pattern[i - 1]) ++i;
if (i != pattern.size()) continue;
std::string number = pad + pattern;
std::sort(number.begin(), number.end());
do {
if (number[0] == '0') continue;
mpz_class n(number);
if (mpz_probab_prime_p(n.get_mpz_t(), 5)) sumOfPrimes += n;
} while (std::next_permutation(number.begin(), number.end()));
} while (getNext(pattern, '0' + d));
if (sumOfPrimes > 0) {
totalSum += sumOfPrimes;
break;
}
}
std::cout << totalSum << "\n";
return 0;
}
/*
* Debug output of an ELF32 program segment
*/
void
elf32DumpProgramSegment(FILE *f, struct ElfObject *obj, const Elf32_Phdr *hdr,
int indent)
{
const char *padding = pad(indent);
static const char *segmentTypeNames[] = {
"PT_NULL",
"PT_LOAD",
"PT_DYNAMIC",
"PT_INTERP",
"PT_NOTE",
"PT_SHLIB",
"PT_PHDR"
};
fprintf(f, "%stype = %xH (%s)\n"
"%soffset = %xH (%d)\n"
"%svirtual address = %xH (%d)\n"
"%sphysical address = %xH (%d)\n"
"%sfile size = %xH (%d)\n"
"%smemory size = %xH (%d)\n"
"%sflags = %xH (%s %s %s)\n"
"%salignment = %xH (%d)\n",
padding, hdr->p_type,
hdr->p_type <= PT_PHDR ? segmentTypeNames[hdr->p_type] : "unknown",
padding, hdr->p_offset, hdr->p_offset,
padding, hdr->p_vaddr, hdr->p_vaddr,
padding, hdr->p_paddr, hdr->p_paddr,
padding, hdr->p_filesz, hdr->p_filesz,
padding, hdr->p_memsz, hdr->p_memsz,
padding, hdr->p_flags,
hdr->p_flags & PF_R ? "PF_R" : "",
hdr->p_flags & PF_W ? "PF_W" : "",
hdr->p_flags & PF_X ? "PF_X" : "",
padding, hdr->p_align, hdr->p_align);
}
void print_element_list(GString *out, element *elt, int format, int exts) {
/* Initialize globals */
endnotes = NULL;
notenumber = 0;
extensions = exts;
padded = 2; /* set padding to 2, so no extra blank lines at beginning */
switch (format) {
case HTML_FORMAT:
print_html_element_list(out, elt, false);
if (endnotes != NULL) {
pad(out, 2);
print_html_endnotes(out);
}
break;
case LATEX_FORMAT:
print_latex_element_list(out, elt);
break;
case GROFF_MM_FORMAT:
if (extensions & EXT_STRIKE) {
g_string_append_printf(out,
".de ST\n.nr width \\w'\\\\$1'\n\\Z@\\v'-.25m'\\l'\\\\n[width]u'@\\\\$1\\c\n..\n.\n");
}
print_groff_mm_element_list(out, elt);
break;
case ODF_FORMAT:
print_odf_header(out);
g_string_append_printf(out, "<office:body>\n<office:text>\n");
if (elt != NULL) print_odf_element_list(out,elt);
print_odf_footer(out);
break;
default:
fprintf(stderr, "print_element - unknown format = %d\n", format);
exit(EXIT_FAILURE);
}
}
void read_sff_file(char* addr) {
sff_common_header* head = (sff_common_header*) addr;
if(ntohl(head->magic) != SFF_MAGIC) {
fprintf(stderr, "Warning: Bad magic number\n");
}
uint32_t nreads = ntohl(head->nreads);
uint16_t header_len = ntohs(head->header_len);
uint16_t flow_len = ntohs(head->flow_len);
char* current_addr = addr + header_len;
for(int i = 0; i < int(nreads); ++i) {
sff_read_header* read = (sff_read_header*) current_addr;
uint16_t rheader_len = ntohs(read->header_len);
uint32_t nbases = ntohl(read->nbases);
uint16_t name_len = ntohs(read->name_len);
uint16_t trim_left = ntohs(read->clip_qual_left) - 1; // these appear to be indexed from 1
uint16_t trim_right = ntohs(read->clip_qual_right) - 1;
/*
printf( "header_len = %d\n"
"name_len = %d\n"
"nbases = %d\n\n",
ntohs(read->header_len),
ntohs(read->name_len),
ntohl(read->nbases));
*/
get_read(current_addr + rheader_len, flow_len, nbases, trim_left, trim_right);
//exit(EXIT_SUCCESS);
current_addr = current_addr + rheader_len + pad((flow_len * 2) + (nbases * 3));
}
}
void endRound(){
if (ccount>21){ //if dealer busts
sleep(1.5);
pad(20); printf("The dealer busted!\n");
win();
}
else if (ccount<pcount){ //neither bust, player wins
sleep(1.5);
pad(20); printf("Your card total of %d is higher than the dealers total of %d.\n", pcount, ccount);
win();
}
else if (ccount>pcount) { //neither bust, dealer wins
sleep(1.5);
pad(20); printf("Your card total of %d is lower than the dealers total of %d.\n", pcount, ccount);
lose();
}
else if (ccount==pcount){ //if its a tie
sleep(1.5);
pad(20); printf("Both you and the dealer had total card count of %d.\n", pcount);
pad(20); printf("It's a Push. Your Chips Are Returned.\n\n");
pad(15); printf("Chip Count: %d\n\n", chips);
}
}
BOOL CALLBACK WORKRULESMsgProc(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
{
static PDISPLAYINFO pDI;
static HANDLE hCtlALLRUNTYPES;
static HANDLE hCtlONERUNTYPE;
static HANDLE hCtlRUNTYPES;
static HANDLE hCtlPREMIUMLIST;
static HANDLE hCtlPREMIUMTIME;
static HANDLE hCtlTIMECOUNTSINOT;
static HANDLE hCtlPREMIUMREPORT;
static HANDLE hCtlTRAVELTIMEPREMIUM;
static HANDLE hCtlDONTPAY;
static HANDLE hCtlDONTINCORPORATE;
static HANDLE hCtlUSECONNIFNOSCHED;
static HANDLE hCtlIDNEWPREMIUM;
static HANDLE hCtlIDSETPREMIUM;
static int runtypeIndex;
static int slotNumber;
static int feasibleRG[4] = {WORKRULES_TIMEENTERED, WORKRULES_ASINCONNECTIONS,
WORKRULES_ASPERSCHEDULE, WORKRULES_ASPERSCHEDULEDWELL};
static int paidHowRG[4] = {WORKRULES_PAYACTUAL, WORKRULES_PAYFLAT,
WORKRULES_PAYPERCENTAGE, WORKRULES_PAYSTAGGERED};
int nI;
int nJ;
int nK;
int nRc;
long tempLong;
BOOL enable;
int rcode2;
short int wmId;
short int wmEvent;
switch(Message)
{
//
// WM_INITDIALOG - Initialize the dialog
//
case WM_INITDIALOG:
pDI = (PDISPLAYINFO)lParam;
if(pDI == NULL)
{
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
break;
}
//
// Set up the handles to the controls
//
hCtlALLRUNTYPES = GetDlgItem(hWndDlg, WORKRULES_ALLRUNTYPES);
hCtlONERUNTYPE = GetDlgItem(hWndDlg, WORKRULES_ONERUNTYPE);
hCtlRUNTYPES = GetDlgItem(hWndDlg, WORKRULES_RUNTYPES);
hCtlPREMIUMLIST = GetDlgItem(hWndDlg, WORKRULES_PREMIUMLIST);
hCtlPREMIUMTIME = GetDlgItem(hWndDlg, WORKRULES_PREMIUMTIME);
hCtlTIMECOUNTSINOT = GetDlgItem(hWndDlg, WORKRULES_TIMECOUNTSINOT);
hCtlPREMIUMREPORT = GetDlgItem(hWndDlg, WORKRULES_PREMIUMREPORT);
hCtlTRAVELTIMEPREMIUM= GetDlgItem(hWndDlg, WORKRULES_TRAVELTIMEPREMIUM);
hCtlUSECONNIFNOSCHED = GetDlgItem(hWndDlg, WORKRULES_USECONNIFNOSCHED);
hCtlDONTPAY = GetDlgItem(hWndDlg, WORKRULES_DONTPAY);
hCtlDONTINCORPORATE = GetDlgItem(hWndDlg, WORKRULES_DONTINCORPORATE);
hCtlIDNEWPREMIUM = GetDlgItem(hWndDlg, IDNEWPREMIUM);
hCtlIDSETPREMIUM = GetDlgItem(hWndDlg, IDSETPREMIUM);
//
// Set up the premium report combo box
//
SendMessage(hWndDlg, WM_USERSETUP, (WPARAM)WORKRULES_PREMIUMREPORT, (LPARAM)0);
//
// Set the "All" runtypes radio button
//
SendMessage(hCtlALLRUNTYPES, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(WORKRULES_ALLRUNTYPES, 0), (LPARAM)0);
//
// So we know if he hasn't picked a premium
//
premiumIndex = NO_RECORD;
//
// Now display the associated premiums with the selected runtype. If there
// are any premiums, the premiumIndex will be reset to the first item in the list box
//
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(WORKRULES_RUNTYPES, CBN_SELCHANGE), (LPARAM)0);
break; // End of WM_INITDIALOG
//
// WM_CLOSE
//
case WM_CLOSE:
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), (LPARAM)0);
break;
//
// WM_USERSETUP:
//
case WM_USERSETUP:
switch(wParam)
{
//
// WORKRULES_PREMIUMREPORT
//
case WORKRULES_PREMIUMREPORT:
strcpy(TABLEVIEWKey1.Name, TABLENAME_RUNS);
pad(TABLEVIEWKey1.Name, TABLEVIEW_NAME_LENGTH);
btrieve(B_GETEQUAL, TMS_TABLEVIEW, &TABLEVIEW, &TABLEVIEWKey1, 1);
CREATEDKey1.File = TABLEVIEW.Id;
CREATEDKey1.Sequence = 0;
rcode2 = btrieve(B_GETGREATEROREQUAL, TMS_CREATED, &CREATED, &CREATEDKey1, 1);
while(rcode2 == 0 &&
CREATED.File == TABLEVIEW.Id)
{
strncpy(tempString, CREATED.Name, CREATED_NAME_LENGTH);
trim(tempString, CREATED_NAME_LENGTH);
nI = SendMessage(hCtlPREMIUMREPORT, CB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)tempString);
ATTRIBUTESKey0.Id = CREATED.Id;
rcode2 = btrieve(B_GETEQUAL, TMS_ATTRIBUTES, &ATTRIBUTES, &ATTRIBUTESKey0, 0);
if(rcode2 != 0)
ATTRIBUTES.formattedDataType = NO_RECORD;
SendMessage(hCtlPREMIUMREPORT, CB_SETITEMDATA, (WPARAM)nI,
MAKELPARAM(ATTRIBUTES.formattedDataType, CREATED.Id));
rcode2 = btrieve(B_GETNEXT, TMS_CREATED, &CREATED, &CREATEDKey1, 1);
}
break;
//
// WORKRULES_RUNTYPES - Set up the combo box
//
case WORKRULES_RUNTYPES:
SendMessage(hCtlRUNTYPES, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
for(nI = 0; nI < NUMRUNTYPES; nI++)
{
for(nJ = 0; nJ < NUMRUNTYPESLOTS; nJ++)
{
if(RUNTYPE[nI][nJ].flags & RTFLAGS_INUSE)
{
nK = SendMessage(hCtlRUNTYPES, CB_ADDSTRING, (WPARAM)0,
(LONG)(LPSTR)RUNTYPE[nI][nJ].localName);
SendMessage(hCtlRUNTYPES, CB_SETITEMDATA, (WPARAM)nK, MAKELPARAM(nI, nJ));
}
}
}
break;
//
// WORKRULES_PREMIUMLIST - Set up the list box based on runtype
//
case WORKRULES_PREMIUMLIST:
nI = SendMessage(hCtlRUNTYPES, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
tempLong = (nI == CB_ERR
? NO_RECORD : SendMessage(hCtlRUNTYPES, CB_GETITEMDATA, (WPARAM)nI, (LPARAM)0));
SendMessage(hCtlPREMIUMLIST, LB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
for(nI = 0; nI < numPremiums; nI++)
{
if(PREMIUM[nI].runtype == tempLong)
{
nJ = SendMessage(hCtlPREMIUMLIST, LB_ADDSTRING, (WPARAM)0, (LONG)(LPSTR)PREMIUM[nI].localName);
SendMessage(hCtlPREMIUMLIST, LB_SETITEMDATA, (WPARAM)nJ, MAKELPARAM(0, nI));
}
}
nI = SendMessage(hCtlPREMIUMLIST, LB_GETCOUNT, (WPARAM)0, (LPARAM)0);
EnableWindow(hCtlIDSETPREMIUM, nI > 0);
if(nI > 0)
{
SendMessage(hCtlPREMIUMLIST, LB_SETCURSEL, (WPARAM)0, (LPARAM)0);
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(WORKRULES_PREMIUMLIST, LBN_SELCHANGE), (LPARAM)0);
nK = SendMessage(hCtlPREMIUMLIST, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
tempLong = SendMessage(hCtlPREMIUMLIST, LB_GETITEMDATA, (WPARAM)nK, (LPARAM)0);
premiumIndex = HIWORD(tempLong);
}
break;
}
break;
//
// WM_COMMAND
//
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
switch(wmId)
{
//
// WORKRULES_TRAVELTIMEPREMIUM check box
//
case WORKRULES_TRAVELTIMEPREMIUM:
enable = SendMessage(hCtlTRAVELTIMEPREMIUM, BM_GETCHECK, (WPARAM)0, (LPARAM)0);
EnableTravelSection(hWndDlg, enable);
if(enable)
{
SendDlgItemMessage(hWndDlg, WORKRULES_TIMEENTERED, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendDlgItemMessage(hWndDlg, WORKRULES_PAYACTUAL, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
}
break;
//
// WORKRULES_TIMEENTERED and WORKRULES_ASINCONNECTIONS radio buttons
//
case WORKRULES_TIMEENTERED:
case WORKRULES_ASINCONNECTIONS:
EnableWindow(hCtlUSECONNIFNOSCHED, FALSE);
break;
//
// WORKRULES_ASPERSCHEDULE and WORKRULES_ASPERSCHEDULEDWELL radio buttons
//
case WORKRULES_ASPERSCHEDULE:
case WORKRULES_ASPERSCHEDULEDWELL:
EnableWindow(hCtlUSECONNIFNOSCHED, TRUE);
break;
//
// WORKRULES_ALLRUNTYPES radio button
// WORKRULES_ONERUNTYPE radio button
//
case WORKRULES_ALLRUNTYPES:
case WORKRULES_ONERUNTYPE:
if(wmId == WORKRULES_ALLRUNTYPES)
{
EnableWindow(hCtlRUNTYPES, FALSE);
SendMessage(hCtlRUNTYPES, CB_RESETCONTENT, (WPARAM)0, (LPARAM)0);
}
else
{
EnableWindow(hCtlRUNTYPES, TRUE);
SendMessage(hWndDlg, WM_USERSETUP, (WPARAM)WORKRULES_RUNTYPES, (LPARAM)0);
if(SendMessage(hCtlRUNTYPES, CB_GETCOUNT, (WPARAM)0, (LPARAM)0) > 0)
SendMessage(hCtlRUNTYPES, CB_SETCURSEL, (WPARAM)0, (LPARAM)0);
}
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(WORKRULES_RUNTYPES, CBN_SELCHANGE), (LPARAM)0);
break;
//
// WORKRULES_RUNTYPES list box
//
case WORKRULES_RUNTYPES:
switch(wmEvent)
{
//
// CBN_SELCHANGE
//
case CBN_SELCHANGE:
nI = SendMessage(hCtlRUNTYPES, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if(nI == LB_ERR)
{
runtypeIndex = NO_RECORD;
slotNumber = NO_RECORD;
}
else
{
tempLong = SendMessage(hCtlRUNTYPES, CB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
runtypeIndex = LOWORD(tempLong);
slotNumber = HIWORD(tempLong);
}
SendMessage(hWndDlg, WM_USERSETUP, (WPARAM)WORKRULES_PREMIUMLIST, (LPARAM)0);
break;
}
break;
//
// WORKRULES_PREMIUMLIST list box
//
case WORKRULES_PREMIUMLIST:
switch(wmEvent)
{
case LBN_SELCHANGE:
nJ = SendMessage(hCtlPREMIUMLIST, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
enable = (nJ != LB_ERR);
EnableWindow(hCtlPREMIUMTIME, enable);
EnableWindow(hCtlTIMECOUNTSINOT, enable);
EnableWindow(hCtlPREMIUMREPORT, enable);
EnableWindow(hCtlIDSETPREMIUM, enable);
EnableWindow(hCtlTRAVELTIMEPREMIUM, enable);
//
// Display the premium characteristics
//
// Pay type
//
if(enable)
{
tempLong = SendMessage(hCtlPREMIUMLIST, LB_GETITEMDATA, (WPARAM)nJ, (LPARAM)0);
nI = HIWORD(tempLong);
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(WORKRULES_PREMIUMTIME, 0), (LPARAM)0);
SendMessage(hCtlPREMIUMTIME, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)chhmm(PREMIUM[nI].time));
//
// Time counts in OT
//
SendMessage(hCtlTIMECOUNTSINOT, BM_SETCHECK,
(WPARAM)(PREMIUM[nI].flags & PREMIUMFLAGS_TIMECOUNTSINOT), (LPARAM)0);
//
// Don't pay when paying intervening time
//
SendMessage(hCtlDONTPAY, BM_SETCHECK,
(WPARAM)(PREMIUM[nI].flags & PREMIUMFLAGS_DONTPAYIFPAYINGINTERVENING),
(LPARAM)0);
//
// Premium reported as...
//
nK = SendMessage(hCtlPREMIUMREPORT, CB_GETCOUNT, (WPARAM)0, (LPARAM)0);
for(nJ = 0; nJ < nK; nJ++)
{
if(PREMIUM[nI].reportedAs ==
HIWORD(SendMessage(hCtlPREMIUMREPORT, CB_GETITEMDATA, (WPARAM)nJ, (LPARAM)0)))
{
SendMessage(hCtlPREMIUMREPORT, CB_SETCURSEL, (WPARAM)nJ, (LPARAM)0);
break;
}
}
//
// Travel time premiums
//
if(!(PREMIUM[nI].flags & PREMIUMFLAGS_TRAVELTIMEPREMIUM))
{
SendMessage(hCtlTRAVELTIMEPREMIUM, BM_SETCHECK, (WPARAM)FALSE, (LPARAM)0);
EnableTravelSection(hWndDlg, FALSE);
}
else
{
SendMessage(hCtlTRAVELTIMEPREMIUM, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
EnableTravelSection(hWndDlg, TRUE);
SendDlgItemMessage(hWndDlg, PREMIUM[nI].payTravelTime, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
if(PREMIUM[nI].payTravelTime == feasibleRG[0] ||
PREMIUM[nI].payTravelTime == feasibleRG[1])
EnableWindow(hCtlUSECONNIFNOSCHED, FALSE);
else if(PREMIUM[nI].flags & PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC)
SendMessage(hCtlUSECONNIFNOSCHED, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
SendDlgItemMessage(hWndDlg, PREMIUM[nI].payHow, BM_SETCHECK, (WPARAM)TRUE, (LPARAM)0);
if(PREMIUM[nI].payHow != WORKRULES_PAYACTUAL)
{
gcvt(PREMIUM[nI].payHowPercent, NUMDECS, tempString);
ltoa(PREMIUM[nI].payHowMinutes, szarString, 10);
if(PREMIUM[nI].payHow == WORKRULES_PAYFLAT)
{
SendDlgItemMessage(hWndDlg, WORKRULES_PAYFLATMINUTES, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)szarString);
}
else if(PREMIUM[nI].payHow == WORKRULES_PAYPERCENTAGE)
{
SendDlgItemMessage(hWndDlg, WORKRULES_PERCENTOFACTUAL, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)tempString);
}
else if(PREMIUM[nI].payHow == WORKRULES_PAYSTAGGERED)
{
SendDlgItemMessage(hWndDlg, WORKRULES_STAGGEREDPERCENT, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)tempString);
SendDlgItemMessage(hWndDlg, WORKRULES_STAGGEREDMINUTES, WM_SETTEXT, (WPARAM)0, (LONG)(LPSTR)szarString);
}
}
}
//
// And set up the premium Index
//
nK = SendMessage(hCtlPREMIUMLIST, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
tempLong = SendMessage(hCtlPREMIUMLIST, LB_GETITEMDATA, (WPARAM)nK, (LPARAM)0);
premiumIndex = HIWORD(tempLong);
}
break;
case LBN_DBLCLK:
SendMessage(hWndDlg, WM_COMMAND, MAKEWPARAM(IDSETPREMIUM, 0), (LPARAM)0);
break;
}
break;
//
// IDNEWPREMIUM - Display the PREMIUMS dialog box, and...
// IDSETPREMIUM - Add a new premium
//
case IDNEWPREMIUM:
case IDSETPREMIUM:
premiumRuntype = runtypeIndex;
premiumTimePeriod = slotNumber;
premiumNew = wmId == IDNEWPREMIUM;
if(!premiumNew)
{
nI = SendMessage(hCtlPREMIUMLIST, LB_GETCURSEL, (WPARAM)0, (LPARAM)0);
tempLong = SendMessage(hCtlPREMIUMLIST, LB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
premiumIndex = HIWORD(tempLong);
}
nRc = DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_PREMIUMS), hWndDlg,
(DLGPROC)PREMIUMSMsgProc, (LPARAM)pDI);
if(nRc)
{
if(wmId == IDNEWPREMIUM)
{
nJ = SendMessage(hCtlRUNTYPES, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
PREMIUM[premiumIndex].runtype =
nJ == CB_ERR ? NO_RECORD : SendMessage(hCtlRUNTYPES, CB_GETITEMDATA, (WPARAM)nJ, (LPARAM)0);
}
SendMessage(hWndDlg, WM_USERSETUP, (WPARAM)WORKRULES_PREMIUMLIST, (LPARAM)0);
}
break;
//
// IDCANCEL Button labelled "Finished"
//
case IDCANCEL:
EndDialog(hWndDlg, FALSE);
break;
//
// IDHELP
//
case IDHELP:
WinHelp(hWndDlg, szarHelpFile, HELP_CONTEXT, Premium_Definition_Step_1);
break;
//
// IDOK Button labelled "Update"
//
case IDOK:
//
// Premiumtype and amount
//
if(premiumIndex != NO_RECORD)
{
SendMessage(hCtlPREMIUMTIME, WM_GETTEXT, (WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
PREMIUM[premiumIndex].time = thhmm(tempString);
//
// Minutes count...
//
if(SendMessage(hCtlTIMECOUNTSINOT, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
PREMIUM[premiumIndex].flags |= PREMIUMFLAGS_TIMECOUNTSINOT;
}
else
{
if(PREMIUM[premiumIndex].flags & PREMIUMFLAGS_TIMECOUNTSINOT)
{
PREMIUM[premiumIndex].flags &= ~PREMIUMFLAGS_TIMECOUNTSINOT;
}
}
//
// Don't pay
//
if(SendMessage(hCtlDONTPAY, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
PREMIUM[premiumIndex].flags |= PREMIUMFLAGS_DONTPAYIFPAYINGINTERVENING;
}
else
{
if(PREMIUM[premiumIndex].flags & PREMIUMFLAGS_DONTPAYIFPAYINGINTERVENING)
{
PREMIUM[premiumIndex].flags &= ~PREMIUMFLAGS_DONTPAYIFPAYINGINTERVENING;
}
}
//
// Premium reported as
//
nI = SendMessage(hCtlPREMIUMREPORT, CB_GETCURSEL, (WPARAM)0, (LPARAM)0);
if(nI == CB_ERR)
{
TMSError(hWndDlg, MB_ICONSTOP, ERROR_091, hCtlPREMIUMREPORT);
break;
}
tempLong = SendMessage(hCtlPREMIUMREPORT, CB_GETITEMDATA, (WPARAM)nI, (LPARAM)0);
PREMIUM[premiumIndex].reportedAs = HIWORD(tempLong);
PREMIUM[premiumIndex].formattedDataType = LOWORD(tempLong);
//
// Travel Time Premium
//
if(!SendMessage(hCtlTRAVELTIMEPREMIUM, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
if(PREMIUM[premiumIndex].flags & PREMIUMFLAGS_TRAVELTIMEPREMIUM)
{
PREMIUM[premiumIndex].flags &= ~PREMIUMFLAGS_TRAVELTIMEPREMIUM;
}
if(PREMIUM[premiumIndex].flags & PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC)
{
PREMIUM[premiumIndex].flags &= ~PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC;
}
PREMIUM[premiumIndex].payTravelTime = NO_RECORD;
PREMIUM[premiumIndex].payHow = NO_RECORD;
PREMIUM[premiumIndex].payHowMinutes = 0;
PREMIUM[premiumIndex].payHowPercent = (float)0.0;
}
else
{
PREMIUM[premiumIndex].flags |= PREMIUMFLAGS_TRAVELTIMEPREMIUM;
for(nI = 0; nI < 4; nI++)
{
if(SendDlgItemMessage(hWndDlg, feasibleRG[nI], BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
PREMIUM[premiumIndex].payTravelTime = feasibleRG[nI];
break;
}
}
if(PREMIUM[premiumIndex].payTravelTime == feasibleRG[0] ||
PREMIUM[premiumIndex].payTravelTime == feasibleRG[1])
{
if(PREMIUM[premiumIndex].flags & PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC)
{
PREMIUM[premiumIndex].flags &= ~PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC;
}
}
else
{
if(SendMessage(hCtlUSECONNIFNOSCHED, BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
PREMIUM[premiumIndex].flags |= PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC;
}
else if(PREMIUM[premiumIndex].flags & PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC)
{
PREMIUM[premiumIndex].flags &= ~PREMIUMFLAGS_USECONNECTIONIFNODYNAMIC;
}
}
for(nI = 0; nI < 4; nI++)
{
if(SendDlgItemMessage(hWndDlg, paidHowRG[nI], BM_GETCHECK, (WPARAM)0, (LPARAM)0))
{
PREMIUM[premiumIndex].payHow = paidHowRG[nI];
strcpy(tempString, "0");
strcpy(szarString, "0");
if(paidHowRG[nI] == WORKRULES_PAYFLAT)
{
SendDlgItemMessage(hWndDlg, WORKRULES_PAYFLATMINUTES, WM_GETTEXT,
(WPARAM)sizeof(szarString), (LONG)(LPSTR)szarString);
}
else if(paidHowRG[nI] == WORKRULES_PAYPERCENTAGE)
{
SendDlgItemMessage(hWndDlg, WORKRULES_PERCENTOFACTUAL, WM_GETTEXT,
(WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
}
else if(PREMIUM[premiumIndex].payHow == WORKRULES_PAYSTAGGERED)
{
SendDlgItemMessage(hWndDlg, WORKRULES_STAGGEREDPERCENT, WM_GETTEXT,
(WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
SendDlgItemMessage(hWndDlg, WORKRULES_STAGGEREDMINUTES, WM_GETTEXT,
(WPARAM)sizeof(szarString), (LONG)(LPSTR)szarString);
}
PREMIUM[premiumIndex].payHowMinutes = atol(szarString);
PREMIUM[premiumIndex].payHowPercent = (float)atof(tempString);
break;
}
}
SendDlgItemMessage(hWndDlg, WORKRULES_STAGGEREDPERCENT, WM_GETTEXT, (WPARAM)TEMPSTRING_LENGTH, (LONG)(LPSTR)tempString);
PREMIUM[premiumIndex].payHowPercent = (float)atof(tempString);
}
}
//
// Point each premium to the appropriate "formattedDataType"
//
SetupPremiumAttributes();
//
// Flag the changes to the INI file
//
m_bWorkrulesChanged = TRUE;
break;
}
break;
default:
return FALSE;
}
return TRUE;
}
int DES_crypt::des_encrypt(const ObString &user_name, const int64_t timestamp, const int64_t skey, char *buffer, int64_t &buffer_length)
{
int err = OB_SUCCESS;
if(buffer_length <= (int64_t)(sizeof(int64_t) + 2 * sizeof(int32_t) + user_name.length()) || buffer_length % 8 != 0)
{
err = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "invalid argument. buffer_length = %ld, should be 80", buffer_length);
}
if(OB_SUCCESS == err)
{
if(user_name.length() == 0)
{
err = OB_INVALID_ARGUMENT;
TBSYS_LOG(WARN, "user_name should not be null. user_name.length=%d", user_name.length());
}
}
if(OB_SUCCESS == err)
{
data_.initialized = 0;
err = stringTobyte(keybyte_, OB_ENRYPT_KEY_BYTE, reinterpret_cast<const char*>(&skey), sizeof(int64_t));
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to stringTobyte. err=%d", err);
}
else
{
setkey_r(keybyte_, &data_);
}
}
int64_t length = 0;
if(OB_SUCCESS == err)
{
length = 2 * sizeof(int32_t) + sizeof(int64_t) + user_name.length();
original_txt_length_ = static_cast<int32_t>(length);
err = pad(txtptr_, OB_MAX_TOKEN_BUFFER_LENGTH, length);
if(OB_SUCCESS != err)
{
TBSYS_LOG(WARN, "fail to pad array. err=%d", err);
}
}
int64_t pos = 0;
if(OB_SUCCESS == err)
{
*(reinterpret_cast<int32_t*>(txtptr_ + pos)) = OB_CRYPT_MAGIC_NUM;
pos += sizeof(int32_t);
*(reinterpret_cast<int32_t*>(txtptr_ + pos)) = user_name.length();
pos += sizeof(int32_t);
memcpy(txtptr_ + pos, user_name.ptr(), user_name.length());
pos += user_name.length();
*(reinterpret_cast<int64_t*>(txtptr_ + pos)) = timestamp;
pos += sizeof(int64_t);
}
if(OB_SUCCESS == err)
{
err = stringTobyte(txtbyte_, OB_ENCRYPT_TXT_BYTE, txtptr_, length);
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to translate string to byte.err=%d", err);
}
}
if(OB_SUCCESS == err)
{
length = length * OB_BYTE_NUM;
char *ptr = txtbyte_;
for(int64_t i = 0; i < length; i += OB_CRYPT_UNIT)
{
ptr = &txtbyte_[i];
encrypt_r(ptr, ENCODE_FLAG, &data_);
}
}
if(OB_SUCCESS == err)
{
err = byteTostring(buffer, buffer_length, txtbyte_, length);
if(err != OB_SUCCESS)
{
TBSYS_LOG(WARN, "fail to translate to string.err=%d", err);
}
else
{
buffer_length = length / OB_BYTE_NUM;
}
}
return err;
}
static int
append_number(struct snprintf_state *state,
u_longest num, unsigned base, const char *rep,
int width, int prec, int flags, int minusp)
{
int len = 0;
u_longest n = num;
char nstr[64]; /* enough for <192 bit octal integers */
int nstart, nlen;
char signchar;
/* given precision, ignore zero flag */
if(prec != -1)
flags &= ~zero_flag;
else
prec = 1;
/* format number as string */
nstart = sizeof(nstr);
nlen = 0;
nstr[--nstart] = '\0';
do {
assert(nstart > 0);
nstr[--nstart] = rep[n % base];
++nlen;
n /= base;
} while(n);
/* zero value with zero precision should produce no digits */
if(prec == 0 && num == 0) {
nlen--;
nstart++;
}
/* figure out what char to use for sign */
if(minusp)
signchar = '-';
else if((flags & plus_flag))
signchar = '+';
else if((flags & space_flag))
signchar = ' ';
else
signchar = '\0';
if((flags & alternate_flag) && base == 8) {
/* if necessary, increase the precision to
make first digit a zero */
/* XXX C99 claims (regarding # and %o) that "if the value and
precision are both 0, a single 0 is printed", but there is
no such wording for %x. This would mean that %#.o would
output "0", but %#.x "". This does not make sense, and is
also not what other printf implementations are doing. */
if(prec <= nlen && nstr[nstart] != '0' && nstr[nstart] != '\0')
prec = nlen + 1;
}
/* possible formats:
pad | sign | alt | zero | digits
sign | alt | zero | digits | pad minus_flag
sign | alt | zero | digits zero_flag */
/* if not right justifying or padding with zeros, we need to
compute the length of the rest of the string, and then pad with
spaces */
if(!(flags & (minus_flag | zero_flag))) {
if(prec > nlen)
width -= prec;
else
width -= nlen;
if(use_alternative(flags, num, base))
width -= 2;
if(signchar != '\0')
width--;
/* pad to width */
len += pad(state, width, ' ');
}
if(signchar != '\0') {
(*state->append_char)(state, signchar);
++len;
}
if(use_alternative(flags, num, base)) {
(*state->append_char)(state, '0');
(*state->append_char)(state, rep[10] + 23); /* XXX */
len += 2;
}
if(flags & zero_flag) {
/* pad to width with zeros */
if(prec - nlen > width - len - nlen)
len += pad(state, prec - nlen, '0');
else
len += pad(state, width - len - nlen, '0');
} else
/* pad to prec with zeros */
len += pad(state, prec - nlen, '0');
while(nstr[nstart] != '\0') {
(*state->append_char)(state, nstr[nstart++]);
++len;
}
if(flags & minus_flag)
len += pad(state, width - len, ' ');
return len;
}
