void bootentry()
{
_mem_init();
parsefun *f = mksequence(mkparsechar('A'),
mksequence(mkparsechar('B'),
mkparsechar('C')));
parsefun *g = mksequence(mkparsechar('D'),
mksequence(mkparsechar('E'),
mkparsechar('F')));
parsefun *z = mkplus(mkchoice(mkparsechar('G'),
mkparsechar('H')));
pcontext *ctx = (pcontext *)malloc(sizeof(pcontext));
ctx -> str = "ABCDEFGHHGGHGHGHGGG000";
ctx -> eof = 0;
ctx -> pos = 0;
ctx -> len = strlen(ctx->str);
int v = runparser(ctx, f);
_printnum("V=", v);
_printnum("POS=", ctx->pos);
v = runparser(ctx, f);
_printnum("V1=", v);
_printnum("POS1=", ctx->pos);
v = runparser(ctx, g);
_printnum("V2=", v);
_printnum("POS2=", ctx->pos);
v = runparser(ctx, z);
_printnum("V3=", v);
_printnum("POS3=", ctx->pos);
_testhalt();
}
/* support for malloc.h */
void init_mem(void *buffer, unsigned int size)
{
# ifdef SAFE
init_mutex(&malloc_mutex);
# endif
_mem_init((unsigned int)buffer, (unsigned int)buffer + size);
}
int mem_test()
{
#if 0
_mem_init();
MEM_T *mem = _mem_alloc(32*1024);
if(mem)
{
LOG_INFO("mem->size = %d",mem->size);
LOG_INFO("mem->phy_addr = %x",mem->phy_addr);
LOG_INFO("mem->vir_addr = %p",mem->vir_addr);
_mem_free(mem);
return 0;
}
else
{
return -1;
}
#else
mem_init();
int phy_addr = 0;
int mem_size = 0;
void *vir_addr = NULL;
void *ptr = mem_alloc(64*1024);
memset(ptr,0,64*1024);
if(ptr)
{
LOG_INFO("ptr is %p\n",ptr);
vir_addr = ptr - 0x8;
LOG_INFO("hisi vir_addr is %p\n",vir_addr);
phy_addr = get_hisi_phy_from_ptr(ptr);
LOG_INFO("phy_addr is %x\n",phy_addr);
mem_size = get_mem_size(ptr);
LOG_INFO("mem_size is %d\n",mem_size);
mem_free(ptr);
}
return 0;
#endif
}
int mem_init()
{
return _mem_init();
}
/*!
* Draft of multiprocessing stuff
*/
Process * prc_create(const char * name, uint32_t stackSize, uint32_t heapSize,
uint32_t * entryPoint, Usermode mode, uint32_t * arg_line, uint32_t * exist_canvas){
if (krn_is_init() == TRUE)
krn_getIdleProcess()->sync_lock = TRUE;
Process * prc = calloc(sizeof(Process));
//memset(prc, 0, sizeof(Process));
// allocate stack
prc->stack = calloc(stackSize * sizeof(char));
prc->heap = calloc(heapSize * sizeof(char) + heapSize);
// info
strcpy(prc->name, name);
prc->pid = totalPIDs++;
prc->context = calloc (sizeof(Ctx));
// copy argument line
if (arg_line != 0){
krn_debugLogf("arg line: %s", (char*)arg_line);
int arg_line_size = (strlen((char*) arg_line) + 2) * sizeof(char);
prc->arg_line = calloc(arg_line_size);
//memset(prc->arg_line, 0, arg_line_size);
strcpy(prc->arg_line, (char*)arg_line);
}
// allocate screen buffer
ScreenInfo info = hw_scr_screenInfo();
prc->screen = calloc(sizeof(ScreenInfo));
if (exist_canvas == NULL){
prc->screen->addr = calloc(info.res_hor * info.res_ver * info.bytes_per_char*2);
prc->screen->res_hor = info.res_hor;
prc->screen->res_ver = info.res_ver;
prc->screen->bytes_per_char = info.bytes_per_char;
prc->screen->cur_x = 0;
prc->screen->cur_y = 0;
prc->exist_canvas = FALSE;
} else {
prc->screen = (ScreenInfo *)exist_canvas;
prc->exist_canvas = TRUE;
}
// new process should take a screen
hw_scr_mapScreenBuffer(prc->screen->addr);
hw_scr_setTextColor(prc->screen, SCR_COLOR_GREEN);
hw_scr_setBackColor(prc->screen, SCR_COLOR_BLACK);
prc->i_should_die = FALSE;
// sutup context stuffs
prc->context->gregs[CPU_REG_SP] = (uint32_t)&prc->stack[stackSize - 1];
prc->context->gregs[CPU_REG_PC] = (uint32_t)entryPoint;
prc->context->flags = mode;
prc->context->gregs[0] = (unsigned int) prc->arg_line;
// insert process to scheduler
if (listPrcLoop == NULL){ // empty scheduler
listPrcLoop = list_new();
}
if (stackFocused == NULL){ // empty focused processes stack
stackFocused = list_new();
}
list_rpush(stackFocused, list_node_new(prc));
currFocusedProc = prc;
// set up events queue
prc->list_msgs = list_new();
// set up first created process (idle) as current. needed in scheduler.
if (currProc == NULL){
currProc = list_rpush(listPrcLoop, list_node_new(prc));
} else {
list_rpush(listPrcLoop, list_node_new(prc));
}
_mem_init(prc->heap, heapSize * sizeof(char), 0);
// synchrinization flag
prc->sync_lock = FALSE;
if (krn_is_init() == TRUE)
krn_getIdleProcess()->sync_lock = FALSE;
return prc;
}
