int main(int argc, char ** argv) {
entropy_context entropy;
// initialize our AES context
aes_init(&aes);
entropy_init(&entropy);
//int ret;
if (argc != 2) {
printf("usage: %s client\n", argv[0]);
return 0;
}
if(__init()) {
printf(" * Exiting \n");
goto exit;
}
if(kvstore_dhm(pfd, &aes, argv[1], enckey, KVSTORE_AESKEY_LEN)) {
printf("\n ! DHM failed... Exiting");
goto exit;
}
// to derive the IV, we just hash the key
// assumed safe, the key IV is updated on each encryption
entropy_func(&entropy, iv, KVSTORE_AESIV_LEN);
send_commands();
exit:
aes_free(&aes);
printf("\n");
return 0;
}
void
_startup (void)
{
_asm
// Initialize the stack pointer
lfsr 1, _stack
lfsr 2, _stack
clrf TBLPTRU, 0 // 1st silicon doesn't do this on POR
bcf __FPFLAGS,RND,0 // Initialize rounding flag for floating point libs
_endasm
_do_cinit ();
loop:
// If user defined __init is not found, the one in clib.lib will be used
__init ();
// Call the user's main routine
main ();
goto loop;
} /* end _startup() */
void
___start(int argc, char **argv, char **envp, void *aux, void (*cleanup)(void))
{
char *s;
environ = envp;
if ((__progname = argv[0]) != NULL) { /* NULL ptr if argc = 0 */
if ((__progname = _strrchr(__progname, '/')) == NULL)
__progname = argv[0];
else
__progname++;
for (s = __progname_storage; *__progname &&
s < &__progname_storage[sizeof __progname_storage - 1]; )
*s++ = *__progname++;
*s = '\0';
__progname = __progname_storage;
}
if (cleanup)
atexit(cleanup);
#ifdef MCRT0
atexit(_mcleanup);
monstartup((u_long)&_eprol, (u_long)&_etext);
#endif
#ifndef SCRT0
__init();
#endif
exit(main(argc, argv, environ));
}
void *
realloc(void *ptr, size_t size)
{
size_t usable;
void *p;
while (real_realloc == NULL){
if (!initializing){
initializing = 1;
__init();
initializing = 0;
}
sched_yield();
}
if (size == 0){
/* size=0,ptr is not NULL => free(ptr); */
free(ptr);
return NULL;
}
ptr = real_realloc(ptr, size + SIZEOF_F_RZ + SIZEOF_SIZE);
usable = malloc_usable_size(ptr);
/* corner cases */
/* ptr is NULL => malloc(size); */
p = ptr + size; /* end of user region */
memset(p, MAGIC_BYTE, SIZEOF_RZ(usable, size));
p += SIZEOF_RZ(usable,size); /* end of redzone */
*(size_t *)p = size;
OFC_DUMP(ptr, usable, size);
return ptr;
}
void
_startup (void)
{
_asm
// Initialize the stack pointer
lfsr 1, _stack
lfsr 2, _stack
clrf TBLPTRU, 0 // 1st silicon doesn't do this on POR
bcf __FPFLAGS,RND,0
// call the part specific module to zero the memory
call __zero_memory, 0
_endasm _do_cinit ();
loop:
// If user defined __init is not found, the one in clib.lib will be used
__init ();
// Call the user's main routine
main ();
goto loop;
} /* end _startup() */
void
___start(int argc, char **argv, char **envp, void *ps_strings,
const void *obj, void (*cleanup)(void))
{
char *s;
environ = envp;
if ((__progname = argv[0]) != NULL) { /* NULL ptr if argc = 0 */
if ((__progname = _strrchr(__progname, '/')) == NULL)
__progname = argv[0];
else
__progname++;
for (s = __progname_storage; *__progname &&
s < &__progname_storage[sizeof __progname_storage - 1]; )
*s++ = *__progname++;
*s = '\0';
__progname = __progname_storage;
}
#if 0
atexit(cleanup);
#endif
#ifdef MCRT0
atexit(_mcleanup);
monstartup((u_long)&_eprol, (u_long)&_etext);
#endif /* MCRT0 */
#ifndef SCRT0
__init();
#endif
__asm("__callmain:"); /* Defined for the benefit of debuggers */
exit(main(argc, argv, envp));
}
void *
malloc(size_t size)
{
size_t usable;
void *ptr, *p;
while(real_malloc == NULL){
if(!initializing){
initializing = 1;
__init();
initializing = 0;
}
sched_yield();
}
ptr = real_malloc(size + SIZEOF_F_RZ + SIZEOF_SIZE);
usable = malloc_usable_size(ptr);
p = ptr + size; /* end of user region */
memset(p, MAGIC_BYTE, SIZEOF_RZ(usable, size));
p += SIZEOF_RZ(usable,size); /* end of redzone */
*(size_t *)p = size;
OFC_DUMP(ptr, usable, size);
return ptr;
}
int
posix_memalign(void **memptr, size_t alignment, size_t size)
{
size_t usable;
void *p;
int ret;
while(real_posix_memalign == NULL){
if(!initializing){
initializing = 1;
__init();
initializing = 0;
}
sched_yield();
}
ret = real_posix_memalign(memptr, alignment,
size + SIZEOF_F_RZ + SIZEOF_SIZE);
if (ret != 0)
return ret;
usable = malloc_usable_size(*memptr);
p = *memptr + size; /* end of user region */
memset(p, MAGIC_BYTE, SIZEOF_RZ(usable, size));
p += SIZEOF_RZ(usable,size); /* end of redzone */
*(size_t *)p = size;
OFC_DUMP(*memptr, usable, size);
return 0;
}
void *
calloc(size_t nmemb, size_t size)
{
size_t newNmemb,newSize,usable;
void *ptr, *p;
while(real_calloc == NULL){
if(!initializing){
initializing = 1;
__init();
initializing = 0;
}
sched_yield();
}
if ((size * nmemb) == 0){
/* corner cases */
/* When size=0 or nmemb=0, */
/* malloc() maybe return minimum block, */
newSize = SIZEOF_F_RZ + SIZEOF_SIZE;
newNmemb = 1;
}else{
newSize = size;
newNmemb = nmemb + ((SIZEOF_F_RZ + SIZEOF_SIZE - 1) / size + 1);
}
ptr = real_calloc(newNmemb ,newSize);
usable = malloc_usable_size(ptr);
p = ((char*)ptr + (size * nmemb)); /* end of user region */
memset(p, MAGIC_BYTE, SIZEOF_RZ(usable, size * nmemb));
p += SIZEOF_RZ(usable,size * nmemb); /* end of redzone */
*(size_t *)p = size * nmemb;
OFC_DUMP(ptr, usable, size * nmemb);
return ptr;
}
WaveformView*
waveform_view_new (Waveform* waveform)
{
PF;
int width = 256, height = 128;
g_return_val_if_fail(glconfig || __init(), NULL);
WaveformView* view = construct ();
GtkWidget* widget = (GtkWidget*)view;
view->waveform = waveform ? g_object_ref(waveform) : NULL;
gtk_widget_set_can_focus(widget, TRUE);
gtk_widget_set_size_request(widget, width, height);
gboolean waveform_view_load_new_on_idle(gpointer _view)
{
WaveformView* view = _view;
g_return_val_if_fail(view, IDLE_STOP);
if(!canvas_init_done){
waveform_view_init_drawable(view);
gtk_widget_queue_draw((GtkWidget*)view); //testing.
}
return IDLE_STOP;
}
int main(int argc, char* argv[])
{
cuInit(0);
int devs = 0;
cuDeviceGetCount(&devs);
assert(devs > 0);
CUdevice dev;
CUresult status;
CUcontext ctx = 0;
cuDeviceGet(&dev, 0);
cuCtxCreate(&ctx, 0, dev);
{
size_t f = 0, t = 0;
CUresult r = cuMemGetInfo(&f, &t);
fprintf( stderr, "Do cuMemGetInfo: %d, %zu/%zu\n", r, f, t );
}
__init("\n");
printf("\nPress any key to exit...");
char c;
scanf("%c", &c);
return 0;
}
/**
* 装载TTA音乐文件
*
* @param spath 短路径名
* @param lpath 长路径名
*
* @return 成功时返回0
*/
static int tta_load(const char *spath, const char *lpath)
{
__init();
if (tta_read_tag(spath) != 0) {
__end();
return -1;
}
if (g_buff != NULL) {
free(g_buff);
g_buff = NULL;
}
g_buff = calloc(TTA_BUFFER_SIZE, sizeof(*g_buff));
if (g_buff == NULL) {
__end();
return -1;
}
if (open_tta_file(spath, &ttainfo, 0, g_io_buffer_size) < 0) {
dbg_printf(d, "TTA Decoder Error - %s", get_error_str(ttainfo.STATE));
close_tta_file(&ttainfo);
return -1;
}
if (player_init(&ttainfo) != 0) {
__end();
return -1;
}
if (ttainfo.BPS == 0) {
__end();
return -1;
}
g_info.samples = ttainfo.DATALENGTH;
g_info.duration = (double) ttainfo.LENGTH;
g_info.sample_freq = ttainfo.SAMPLERATE;
g_info.channels = ttainfo.NCH;
g_info.filesize = ttainfo.FILESIZE;
if (xAudioInit() < 0) {
__end();
return -1;
}
if (xAudioSetFrequency(ttainfo.SAMPLERATE) < 0) {
__end();
return -1;
}
xAudioSetChannelCallback(0, tta_audiocallback, NULL);
generic_lock();
g_status = ST_LOADED;
generic_unlock();
return 0;
}
AVIRenderer* AVIRenderer::load(const SPtr<AVIReader>& reader)
{
__init();
if(!reader->video_header() || !reader->video_format())
return NULL;
if(!_map_fcc_codecid.count(((AVISTREAMHEADER*)reader->video_header())->fccHandler) && !_map_fcc_codecid.count(((BITMAPINFO*)reader->video_format())->bmiHeader.biCompression))
{
// handle in another way, custom rgba 32-bit raw or png
if(((BITMAPINFO*)reader->video_format())->bmiHeader.biCompression != *(DWORD*)"PNG " && ((BITMAPINFO*)reader->video_format())->bmiHeader.biCompression != 0)
return NULL;
if(((BITMAPINFO*)reader->video_format())->bmiHeader.biBitCount != 32 && ((BITMAPINFO*)reader->video_format())->bmiHeader.biBitCount != 24 )
return NULL;
AVIRenderer* renderer = new AVIRenderer();
renderer->_reader = reader;
((AVIRendererInternal*)renderer->_internal)->fip.setSize(FIT_BITMAP, (WORD)((BITMAPINFO*)reader->video_format())->bmiHeader.biWidth, (WORD)((BITMAPINFO*)reader->video_format())->bmiHeader.biHeight, ((BITMAPINFO*)reader->video_format())->bmiHeader.biBitCount);
return renderer;
}
unsigned long fcc = ((AVISTREAMHEADER*)reader->video_header())->fccHandler;
if(!(_map_fcc_codecid.count(fcc) && avcodec_find_decoder((CodecID)_map_fcc_codecid[fcc])))
{
fcc = ((BITMAPINFO*)reader->video_format())->bmiHeader.biCompression;
if(!(_map_fcc_codecid.count(fcc) && avcodec_find_decoder((CodecID)_map_fcc_codecid[fcc])))
return NULL;
}
AVCodec* codec = avcodec_find_decoder((CodecID)_map_fcc_codecid[fcc]);
AVCodecContext* ctx = avcodec_alloc_context();
ctx->stream_codec_tag = ((AVISTREAMHEADER*)reader->video_header())->fccHandler;
ctx->width = ((BITMAPINFO*)reader->video_format())->bmiHeader.biWidth;
ctx->height = ((BITMAPINFO*)reader->video_format())->bmiHeader.biHeight;
ctx->codec_tag = ((AVISTREAMHEADER*)reader->video_header())->fccHandler;
// handle this carefully, is BITMAPINFOHEADER, not BITMAPINFO (which includes at least one RGBQUAD)
ctx->extradata = (uint8_t*)((BITMAPINFOHEADER*)reader->video_format()+1);
ctx->extradata_size = ((BITMAPINFO*)reader->video_format())->bmiHeader.biSize-sizeof(BITMAPINFOHEADER);
if(avcodec_open(ctx,codec) != 0)
{
avcodec_close(ctx);
return NULL;
}
AVIRenderer* renderer = new AVIRenderer();
renderer->_reader = reader;
AVIRendererInternal* intn = (AVIRendererInternal*)renderer->_internal;
intn->ctx = ctx;
intn->src = avcodec_alloc_frame();
intn->dst = avcodec_alloc_frame();
intn->fip.setSize(FIT_BITMAP, (WORD)ctx->width, (WORD)ctx->height, 24);
avpicture_fill((AVPicture*)(intn->dst), intn->fip.accessPixels(), PIX_FMT_BGR24, ctx->width, ctx->height);
intn->dst->linesize[0] = intn->fip.getScanWidth();
SwsParams p;
memset(&p, 0, sizeof(p));
intn->sws = sws_getContext(ctx->width, ctx->height, csp_ffdshow2mplayer(csp_lavc2ffdshow(ctx->pix_fmt)), intn->fip.getWidth(), intn->fip.getHeight(), csp_ffdshow2mplayer(csp_lavc2ffdshow(PIX_FMT_BGR24)), &p, NULL, NULL, NULL);
return renderer;
}
strstreambuf::strstreambuf(char* __gnext, streamsize __n, char* __pbeg)
: __strmode_(),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init(__gnext, __n, __pbeg);
}
strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
: __strmode_(__constant),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init((char*)__gnext, __n, nullptr);
}
strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
: __strmode_(__constant),
__alsize_(__default_alsize),
__palloc_(nullptr),
__pfree_(nullptr)
{
__init(const_cast<char *>(reinterpret_cast<const char*>(__gnext)), __n, nullptr);
}
PulseProcessor::PulseProcessor(double dT_ms, ProcessType type)
{
switch(type){
case HeartRate:
__init(7500.0, 400.0, 350.0, dT_ms, type);
break;
}
}
MapControl::MapControl(QSize size, MouseMode mousemode, bool showScale, bool showCrosshairs, QWidget * parent, Qt::WindowFlags windowFlags)
: QWidget( parent, windowFlags ),
size(size),
mymousemode(mousemode),
scaleVisible(showScale),
crosshairsVisible(showCrosshairs)
{
__init();
}
int startPLC(int argc,char **argv)
{
if(__init(argc,argv) == 0){
PLC_SetTimer(0, common_ticktime__);
return 0;
}else{
return 1;
}
}
MapControl::MapControl (QWidget * parent, Qt::WindowFlags windowFlags)
: QWidget( parent, windowFlags ),
size(100,100),
mymousemode(Panning),
scaleVisible(false),
crosshairsVisible(true)
{
__init();
}
CurlWrapper()
{
memset(__error_buffer, 0, sizeof(__error_buffer));
__handle = curl_easy_init();
if (!__handle)
{
fatal2(__("unable to create a Curl handle"));
}
__init();
}
// Constructors
SWIPLContainer::SWIPLContainer(const QStringList &args)
{
char *av[args.size()+1];
for(int i = 0; i < args.size(); i++) {
av[i] = (char *)((const char *) args.at(i).toAscii());
}
av[args.size()] = NULL;
__init(args.size(), av);
}
void DeviceMatrixCommon::__open() throw(string)
{
if(_fd != -1)
throw(string("DeviceMatrixCommon::__open: device not closed"));
if((_fd = ::open(_device_node.c_str(), O_RDWR | O_NOCTTY | O_EXCL, 0)) < 0)
throw(string("DeviceMatrixCommon::DeviceMatrixCommon::open(") + _device_node + ")");
ioctl(_fd, TIOCEXCL, 1);
_initserial();
__init();
}
void _start(int argc, char **argv)
{
memoryInitialize();
__init();
fsdev_init();
int ret = main(argc, argv);
fsdev_exit();
// __fini();
memoryRelease();
SYSRelaunchTitle(0, 0);
exit(0);
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL,DWORD fdwReason,LPVOID lpvReserved)
{
if(fdwReason == DLL_PROCESS_ATTACH)
{
WSADATA wsadata;
WSAStartup(MAKEWORD(2,1),&wsadata);
__init();
}else if (fdwReason == DLL_PROCESS_DETACH)
{
__finit();
WSACleanup();
}
}
//! prepare for capacity
explicit map( size_t n, const as_capacity_t & ) :
itmax(n),
slots( htable::compute_slots_for(itmax) ),
klist(),
kpool(0,0),
hslot(0),
hpool(0,0),
wlen(0),
wksp(0),
hash(),
hmem()
{
__init();
}
/* HBL elf entry point */
int __entry_menu(int argc, char **argv)
{
InitFunctionPointers();
memoryInitialize();
__init();
fsdev_init();
int ret = main(argc, argv);
fsdev_exit();
// __fini();
memoryRelease();
return ret;
}
void __interrupt() __frame() Reset_Handler( void )
{
/* Set flash wait states to 3 */
PREF_FCON = (PREF_FCON & 0xFFFFFFF0) | 0x00000003;
SCU_GCU_PEFLAG =0xFFFFFFFF; /* Clear existing parity errors if any */
SCU_GCU_PEEN = 0; /* Disable parity */
/*
* Anticipate possible ROM/RAM remapping
* by loading the 'real' program address.
*/
__remap_pc();
/*
* Initialize stack pointer.
*/
__setsp( _lc_ub_stack );
/*
* Call a user function which initializes hardware,
* such as ROM/RAM re-mapping or MMU configuration.
*/
SystemInit();
/*
* Copy initialized sections from ROM to RAM
* and clear uninitialized data sections in RAM.
*/
__init();
__asm( "_cptable_handled:" ); /* symbol may be used by debugger */
/*
* Load VTOR register with the actual vector table
* start address
*/
VTOR = (unsigned int)_lc_vtor_value;
#ifdef __POSIX__
__setsp( _posix_boot_stack_top );
#endif
#if __PROF_ENABLE__
__prof_init();
#endif
#ifdef __POSIX__
exit( posix_main() );
#elif defined __USE_ARGC_ARGV
exit( main( _argcv( argcv, __ARGCV_BUFSIZE ), (char **)argcv ) );
#else
exit( main( 0, NULL ) );
#endif
return;
}
SWIPLContainer::SWIPLContainer()
{
// Run with empty params by default
char *argv[] = {
#ifdef Q_OS_WIN
(char*) "",
#else
(char*) QCoreApplication::argv()[0],
#endif
(char*) "-g",
(char*) "true",
NULL
};
__init(3, argv);
}
//! copy ctor
explicit map( const map &other ) :
itmax(other.size()),
slots(htable::compute_slots_for(itmax)),
klist(),
kpool(0,0),
hslot(0),
hpool(0,0),
wlen(0),
wksp(0),
hash(),
hmem()
{
__init();
try { other.__duplicate_into( *this ); }
catch(...) {__release(); throw; }
}
