object *lookup_variable_value(object *var, object *env) {
object *frame;
object *vars;
object *vals;
if (debug)
{
fprintf(stderr, "entering lookup_variable_value searching for %s\n", var->data.symbol.value);
}
while (!is_the_empty_list(env)) {
frame = first_frame(env);
vars = frame_variables(frame);
vals = frame_values(frame);
if (debug)
{
fprintf(stderr, "1 searching symbol %s\n", var->data.symbol.value);
fprintf(stderr, "1 vars %p\n", vars);
}
while (!is_the_empty_list(vars)) {
if (is_pair(vars)) {
if (var == car(vars)) {
if (debug)
{
fprintf(stderr, "vals---\n");
write(stdout, is_pair(vals) ? car(vals) : the_empty_list);
fflush(stdout);
fprintf(stderr, "\nend---\n");
}
return is_pair(vals) ? car(vals) : the_empty_list;
}
}
else if(is_symbol(vars)) {
if (debug)
{
fprintf(stderr, "2 searched symbol %s\n", var->data.symbol.value);
fprintf(stderr, "last cdr symbol %s\n", vars->data.symbol.value);
}
if (var == vars) {
if (debug)
{
fprintf(stderr, "vals---\n");
write(stdout, vals);
fflush(stdout);
fprintf(stderr, "\nend---\n");
}
return vals;
}
else
{
break;
}
}
vars = cdr(vars);
vals = cdr(vals);
}
env = enclosing_environment(env);
}
fprintf(stderr, "unbound variable, %s\n", var->data.symbol.value);
exit(1);
}
int
main ()
{
first_frame ();
return 0;
}
void page_alloc(struct page *p, int flags)
{
uint32_t idx;
ASSERT(p != NULL);
if (p->frame != 0) {
DEBUG(DL_WRN, ("page(%p), frame(%x), flags(%d)\n",
p, p->frame, flags));
PANIC("alloc page in use");
} else {
spinlock_acquire(&_pages_lock);
/* Get the first free frame from our global frame set */
idx = first_frame();
if (idx == (uint32_t)(-1)) {
PANIC("No free frames!\n");
}
/* Mark the frame address as being used */
set_frame(idx * PAGE_SIZE);
spinlock_release(&_pages_lock);
p->present = 1;
p->frame = idx;
}
#ifdef _DEBUG_MM
DEBUG(DL_DBG, ("page(%p), frame(%x).\n", p, p->frame));
#endif /* _DEBUG_MM */
}
kma_frame* get_frame(kma_frame* wanted){
kma_frame* current = first_frame();
while(current != wanted){
current = current->next;
}
return current;
}
u32int alloc_frame()
{
u32int idx = first_frame();
if(idx == 0xffffffff){
//full先这么着，换页的事儿后面再写
PANIC("full");
}
u32int ret = idx * 0x1000;
set_frame(ret);
return ret;
}
void set_variable_value(item unev, item val, item env){
item vars, vals;
while (!eq(env, the_empty_environment())){
vars = frame_variables(first_frame(env));
vals = frame_value(first_frame(env));
while (1){
if (is_null(vars)){
env = enclosing_environment(env);
break;
}
else if (eq(unev, car(vars))){
set_car(vals, val);
}
else {
vars = cdr(vars);
vals = cdr(vals);
}
}
}
}
static inline void deinterlace_get_closest_frames(obs_source_t *s,
uint64_t sys_time)
{
const struct video_output_info *info;
uint64_t half_interval;
if (!s->async_frames.num)
return;
info = video_output_get_info(obs->video.video);
half_interval = (uint64_t)info->fps_den * 500000000ULL /
(uint64_t)info->fps_num;
if (first_frame(s) || ready_deinterlace_frames(s, sys_time)) {
uint64_t offset;
s->prev_async_frame = NULL;
s->cur_async_frame = s->async_frames.array[0];
da_erase(s->async_frames, 0);
if (s->cur_async_frame->prev_frame) {
s->prev_async_frame = s->cur_async_frame;
s->cur_async_frame = s->async_frames.array[0];
da_erase(s->async_frames, 0);
s->deinterlace_half_duration = (uint32_t)
((s->cur_async_frame->timestamp -
s->prev_async_frame->timestamp) / 2);
} else {
s->deinterlace_half_duration = (uint32_t)
((s->cur_async_frame->timestamp -
s->deinterlace_frame_ts) / 2);
}
if (!s->last_frame_ts)
s->last_frame_ts = s->cur_async_frame->timestamp;
s->deinterlace_frame_ts = s->cur_async_frame->timestamp;
offset = obs->video.video_time - s->deinterlace_frame_ts;
if (!s->deinterlace_offset) {
s->deinterlace_offset = offset;
} else {
uint64_t offset_diff = uint64_diff(
s->deinterlace_offset, offset);
if (offset_diff > half_interval)
s->deinterlace_offset = offset;
}
}
}
item lookup_variable_value(item exp, item env){
item vars, vals;
while (!eq(env, the_empty_environment())){
vars = frame_variables(first_frame(env));
vals = frame_value(first_frame(env));
while (1){
if (is_null(vars)){
env = enclosing_environment(env);
break;
}
else if (eq(exp, car(vars))){
return car(vals);
}
else {
vars = cdr(vars);
vals = cdr(vals);
}
}
}
fprintf(stderr, "Unbound variable");
exit(1);
}
void alloc_frame(struct page *page, int kernel, int writable)
{
uint32_t idx;
if (page->frame) return;
else
{
idx = first_frame();
if (idx == (uint32_t)-1)
PANIC("No free frames!");
set_frame(idx*PAGE_SIZ);
page->present = 1;
page->rw = writable;
page->user = kernel;
page->frame = idx;
}
}
/* Function to allocate a frame */
void frame_alloc(struct page* p, int is_kernel, int is_writable)
{
if (p->frame != 0)
{
/* Frame was already allocated */
return;
}
else
{
addr idx = first_frame(); /* The first free frame */
if (idx == (addr) - 1)
PANIC("No free frames!");
set_frame(idx*0x1000); /* This frame is now ours */
p->present = 1; /* Mark it as present */
p->rw = (is_writable)?1:0; /* Should the page be writable? */
p->user = (is_kernel)?0:1; /* Should the page be user-mode? */
p->frame = idx;
}
}
void alloc_frame(page_t* page, int kernel, int writeable)
{
if(page->frame!=0)
{
return;
}
else
{
uint32_t idx=first_frame();
if(idx==(uint32_t)-1)
{
panic("No free frames!");
}
set_frame(idx*0x1000);
page->present=1;
page->rw=(writeable) ? 1 : 0;
page->user=(kernel) ? 0 : 1;
page->frame=idx;
}
}
void define_variable(item unev, item val, item env){
item frame = first_frame(env);
item vars, vals;
vars = frame_variables(frame);
vals = frame_value(frame);
while (1){
if (is_null(vars)){
add_binding_to_frame(unev, val, frame);
break;
}
else if (eq(unev, car(vars))){
set_car(vals, val);
break;
}
else{
vars = cdr(vars);
vals = cdr(vals);
}
}
}
void print_debug(){
kma_frame* current = first_frame();
while(current->last != LAST){
fprintf(stdout, "frame: %p, page: %p, prev: %p, next: %p, occupied: %x, last: %x, \n",
current, current->page, current->prev, current->next, current->occupied, current->last);
current = current->next;
}
fprintf(stdout, "frame: %p, page: %p, prev: %p, next: %p, occupied: %x, last: %x, \n",
current, current->page, current->prev, current->next, current->occupied, current->last);
fprintf(stdout, "================================================\n");
}
/*
* Function to allocate a frame.
*/
void alloc_frame(page_t* page, bool is_kernel, bool is_writeable) {
if (page->frame != 0) {
return;
} else {
uint32_t idx = first_frame();
if (idx == (uint32_t) -1) {
PANIC("No Free Frames");
}
set_frame(idx * 0x1000);
// Clear the page's memory!
memclr(page, sizeof(page_t));
page->present = 1;
page->rw = (is_writeable) ? 1 : 0;
page->user = (is_kernel) ? 0 : 1;
page->frame = idx;
// kprintf("Mapped page at phys 0x%X\n", idx * 0x1000);
}
}
void alloc_frame(page_entry_t *page, int32_t is_kernel, int32_t is_writeable)
{
if (page->frame != 0)
{
page->present = 1;
page->rw = (is_writeable) ? 1 : 0;
page->user = (is_kernel) ? 0 : 1;
return;
}
else
{
uint32_t idx = first_frame();
if (idx == (uint32_t)-1)
{
PANIC("No free frame");
}
set_frame(idx*0x1000);
page->frame = idx;
page->present = 1;
page->rw = (is_writeable) ? 1 : 0;
page->user = (is_kernel) ? 0 : 1;
page->frame = idx;
}
}
void set_variable_value(object *var, object *val, object *env) {
object *frame;
object *vars;
object *vals;
object *prevals;
while (!is_the_empty_list(env)) {
frame = first_frame(env);
vars = frame_variables(frame);
vals = frame_values(frame);
if (debug)
{
printf("\n---env\n"); write(stdout, env);
printf("\n---frame\n"); write(stdout, frame);
printf("\n---vars\n"); write(stdout, vars);
printf("\n---vals\n"); write(stdout, vals);
printf("\n---\n");
}
while (!is_the_empty_list(vars)) {
/* if (var == car(vars)) { */
/* set_car(vals, val); */
/* return; */
/* } */
if (is_pair(vars)) {
// printf("ispair\n");
if (var == car(vars)) {
if (debug)
{
printf("found match\n");
printf("\n---vals\n");
write(stdout, vals);
}
if (is_pair(vals))
{
set_car(vals, val);
return;
}
else /* TODO */
{
set_cdr(prevals, cons(val, the_empty_list));
return;
}
}
}
else if(is_symbol(vars)) {
if (debug)
{
printf("symbol\n");
fprintf(stderr, "2 searched symbol %s\n", var->data.symbol.value);
fprintf(stderr, "last cdr symbol %s\n", vars->data.symbol.value);
}
if (var == vars) {
if (debug)
{
printf("\n---vals\n"); write(stdout, vals);
printf("\n---prevals\n"); write(stdout, prevals);
}
// assert(0);
set_cdr(prevals, val);
// return vals;
return;
}
else
{
if (debug)
{
printf("\nx yes\n");
}
// assert(0);
break;
}
}
vars = cdr(vars);
prevals = vals;
vals = cdr(vals);
}
env = enclosing_environment(env);
}
fprintf(stderr, "unbound variable, %s\n", var->data.symbol.value);
exit(1);
}
void define_variable(object *var, object *val, object *env) {
object *frame;
object *vars;
object *vals;
object *prevals;
frame = first_frame(env);
vars = frame_variables(frame);
vals = frame_values(frame);
while (!is_the_empty_list(vars)) {
/* if (var == car(vars)) { */
/* set_car(vals, val); */
/* return; */
/* } */
if (is_pair(vars)) {
// printf("ispair\n");
if (var == car(vars)) {
if (debug)
{
printf("found match\n");
printf("\n---vals\n"); write(stdout, vals);
}
if (is_pair(vals))
{
set_car(vals, val);
return;
}
else
{
assert(0);
}
}
}
else if(is_symbol(vars)) {
if (debug)
{
printf("symbol\n");
fprintf(stderr, "2 searched symbol %s\n", var->data.symbol.value);
fprintf(stderr, "last cdr symbol %s\n", vars->data.symbol.value);
}
if (var == vars) {
if (debug)
{
printf("\n---vals\n"); write(stdout, vals);
printf("\n---prevals\n"); write(stdout, prevals);
}
// assert(0);
set_cdr(prevals, val);
// return vals;
return;
}
else
{
printf("\nx yes\n");
// assert(0);
break;
}
}
vars = cdr(vars);
prevals = vals;
vals = cdr(vals);
}
add_binding_to_frame(var, val, frame);
}
int main(int argc,char *argv[])
{
/*+++++++++++++++++Определения переменных функции main()+++++++++++++++++++++++++++++++++++*/
unsigned char c; /*Код клавиши (комбинации клавиш), который вводим.*/
unsigned char func_c; /*Флаг функциональной клавиши*/
unsigned char shift; /*Флаг нажатия shift*/
/*++++++++++++++++++Объявления внешних переменных используемых в main()++++++++++++++++++++*/
extern int line,pos; /*Положение курсора относительно строк редактируемого файла*/
extern int xt,yt,xk,yk; /*Координаты окна экрана(xk, yk) и массива(xt, yt)*/
start(argc,argv);
first_frame();
/*Основной цикл*/
while(1)
{
/*При нажатии функциональных клавиш, в отличии от обычных, возвращается не один код, а два:
первый 0 или 224 (0xE0) (зависит от того, на какой клавиатуре нажата функциональная клавиша:
основной или дополнительной), а второй - уже непосредственно код функциональной клавиши.
Например, при нажатии стрелки влево в буфер клавиатуры попадет два байта: 224 и 74. Все было бы
хорошо, но 224 - это код русской буквы "а" (для данного locale), поэтому нужна дополнительная
проверка на пустоту буфера. */
c=getch(); /*Считывание нажатой клавиши*/
func_c=0; /*Сброс флага нажатия функциональной клавиши*/
if(kbhit() && (c==0x0 || c==0xE0)) /*Если буфер клавиатуры не пуст и считанный код равен 0 или 224*/
{
c=getch(); /*Считывание расширенного кода*/
func_c=1; /*Установка флага нажатия функциональной клавиши*/
}
/*------------------------------------------------------------------------------*/
/*Проверка нажатия shift (при пошаговой отладке не работает)*/
shift=(GetKeyState(VK_SHIFT) & PRESS)?1:0;
/*------------------------------------------------------------------------------*/
line=yk+yt; /*Cтрока, в которой сейчас находится курсор*/
pos=xk+xt; /*Столбец, в котором сейчас находится курсор*/
/*------------------------------------------------------------------------------*/
if(!func_c) /*Обработка символьных клавиш, и символьных управляющих клавиш*/
switch(c)
{
case 2: /*Ctrl-B*/
ctrl_b();
break;
case 5: /*Ctrl-E*/
ctrl_e();
break;
case 14: /*Ctrl-N*/
ctrl_n();
break;
case 21: /*Ctrl-U*/
ctrl_u();
break;
case 27: /*Esc*/
esc();
case 68: /*shift_D*/
shift_d(shift);
break;
default: /*Indent*/
if(c>31) /*Исключаем управляющие символы*/
indent(c);
break;
}
else /*Обработка функциональных клавиш*/
switch(c)
{
case 72: /*Up*/
up(shift);
break;
case 80: /*Down*/
down(shift);
break;
case 75: /*Left*/
left(shift);
break;
case 77: /*Right*/
right(shift);
break;
case 73: /*PgUp*/
pageup();
break;
case 81: /*PgDown*/
pagedown();
break;
case 83: /*del*/
del();
break;
case 71: /*Home*/
home();
break;
case 79: /*End*/
end();
break;
case 119: /*Ctrl-Home*/
ctrl_home();
break;
case 117: /*Ctrl-End*/
ctrl_end();
break;
case 93: /*Shift-F10*/
shift_f10(argv[1]);
case 59: /*F1*/
f1();
break;
case 60: /*F2*/
f2(argv[1]);
break;
case 65: /*F7*/
f7();
break;
}
}
}
