예제 #1
0
void free_page_structure(uintptr_t vaddress, uintptr_t cr3) {
    v_address_t va;
    memcpy(&va, &vaddress, 8);

    puint_t* pml4 = (puint_t*)ALIGN(physical_to_virtual(cr3));
    if (!PRESENT(pml4[va.pml])) {
        return;
    }

    puint_t* pdpt = (puint_t*)ALIGN(physical_to_virtual(pml4[va.pml]));

    if (!PRESENT(pdpt[va.directory_ptr])) {
        return;
    }

    puint_t* pdir = (puint_t*)ALIGN(physical_to_virtual(pdpt[va.directory_ptr]));

    if (!PRESENT(pdir[va.directory])) {
        return;
    }

    puint_t* pt = (puint_t*)ALIGN(physical_to_virtual(pdir[va.directory]));
    pt[va.table] = 0; // free table entry

    // check for other table entries
    for (size_t i=0; i<512; i++) {
        if (pt[i] != 0)
            return;
    }

    free_frame(ALIGN(pdir[va.directory]));
    pdir[va.directory] = 0; // free pt address

    // check for other pdir adresses
    for (size_t i=0; i<512; i++) {
        if (pdir[i] != 0)
            return;
    }

    free_frame(ALIGN(pdpt[va.directory_ptr]));
    pdpt[va.directory_ptr] = 0; // free pdir address

    for (size_t i=0; i<512; i++) {
        if (pdpt[i] != 0)
            return;
    }

    free_frame(ALIGN(pml4[va.pml]));
    pml4[va.pml] = 0; // free pdpt address
}
예제 #2
0
/**
 * Initializes memory mirror.
 *
 * Memory mirror allocates all available ram to specific range address.
 * If 1GB paging is supported, 1GB paging is used, otherwise only 4KB
 * paging is used, which means much more physical ram is used.
 */
void initialize_memory_mirror() {
    section_info_t* head = frame_pool;
    frame_pool = NULL;
    bool first_set = false;
    if (is_1GB_paging_supported() != 0) {
        for (puint_t start=0; start < maxram; start+=1<<30) {
            puint_t vaddress = start + ADDRESS_OFFSET(RESERVED_KBLOCK_RAM_MAPPINGS);
            v_address_t va;
            memcpy(&va, &vaddress, 8);

            puint_t* pml4 = (puint_t*)ALIGN(physical_to_virtual(get_active_page()));
            if (!PRESENT(pml4[va.pml])) {
                pdpt_t pdpt;
                memset(&pdpt, 0, sizeof(pdpt_t));
                pdpt.number = get_free_frame();
                pdpt.flaggable.present = 1;
                pdpt.flaggable.us = 0;
                pdpt.flaggable.rw = 1;
                pml4[va.pml] = pdpt.number;
                memset((void*)physical_to_virtual(ALIGN(pdpt.number)), 0, 0x1000);
            }

            puint_t* pdpt = (puint_t*)ALIGN(physical_to_virtual(pml4[va.pml]));

            page_directory1GB_t dir;
            memset(&dir, 0, sizeof(page_directory1GB_t));
            dir.number = start;
            dir.flaggable.present = 1;
            dir.flaggable.ps = 1;
            dir.flaggable.rw = 1;
            pdpt[va.directory_ptr] = dir.number;

            if (!first_set) {
                first_set = true;
                frame_pool = head;
            }
        }
    } else {
        for (puint_t start=0; start < maxram; start+=0x1000) {
            puint_t kend = kernel_tmp_heap_start - 0xFFFFFFFF80000000 + 0x40000;
            if (kend+0x4000 >= tmp_heap && !first_set) {
                first_set = true;
                frame_pool = head;
            }

            puint_t vaddress = start + ADDRESS_OFFSET(RESERVED_KBLOCK_RAM_MAPPINGS);
            puint_t* paddress = get_page(vaddress, get_active_page(), true);
            page_t page;
            memset(&page, 0, sizeof(page_t));
            page.address = start;
            page.flaggable.present = 1;
            page.flaggable.rw = 1;
            page.flaggable.us = 0;
            *paddress = page.address;
        }

    }
}
예제 #3
0
/**
 * Computes virtual to physical mapping.
 *
 * Checks for page hierarchy and determines what physical address will be.
 * If page structures are missing on the way to decode, physical address cannot
 * be found and this valid will contain 0, otherwise valid will contain 1
 *
 * 1GB page sector (ram identity map) behaves slightly different, because it
 * needs different v_address_t type.
 */
ruint_t virtual_to_physical(uintptr_t vaddress, uintptr_t cr3, uint8_t* valid) {
    *valid = 1;
    v_address_t va;
    memcpy(&va, &vaddress, 8);

    puint_t* address = (puint_t*)ALIGN(physical_to_virtual(cr3));
    address = (puint_t*)ALIGN(physical_to_virtual(address[va.pml]));

    if (!PRESENT(address)) {
        *valid = 0;
        return 0;
    }

    if (vaddress > ADDRESS_OFFSET(RESERVED_KBLOCK_RAM_MAPPINGS) &&
                vaddress < ADDRESS_OFFSET((RESERVED_KBLOCK_RAM_MAPPINGS+1)) &&
                is_1GB_paging_supported()) {
        v_address1GB_t va = *((v_address1GB_t*) &vaddress);
        page_directory1GB_t pd1gb;
        pd1gb.number = (uint64_t) address;
        return pd1gb.flaggable.address + va.offset;
    }

    address = (puint_t*)ALIGN(physical_to_virtual(address[va.directory_ptr]));

    if (!PRESENT(address)) {
        *valid = 0;
        return 0;
    }

    address = (puint_t*)ALIGN(physical_to_virtual(address[va.directory]));

    if (!PRESENT(address)) {
        *valid = 0;
        return 0;
    }

    if (!PRESENT(*address)) {
        *valid = 0;
        return 0;
    }

    puint_t physadd = *address;
    return ALIGN(physadd) + va.offset;
}
예제 #4
0
파일: trim_sgr0.c 프로젝트: 2asoft/freebsd
static char *
set_attribute_9(TERMTYPE *tp, int flag)
{
    const char *value;
    char *result;

    value = tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, flag);
    if (PRESENT(value))
	result = strdup(value);
    else
	result = 0;
    return result;
}
예제 #5
0
파일: trim_sgr0.c 프로젝트: unixpunx/bitrig
/*
 * Improve similar_sgr a little by moving the attr-string from the beginning
 * to the end of the s-string.
 */
static bool
rewrite_sgr(char *s, char *attr)
{
    if (PRESENT(s)) {
        if (PRESENT(attr)) {
            unsigned len_s = strlen(s);
            unsigned len_a = strlen(attr);

            if (len_s > len_a && !strncmp(attr, s, len_a)) {
                unsigned n;
                TR(TRACE_DATABASE, ("rewrite:\n\t%s", s));
                for (n = 0; n < len_s - len_a; ++n) {
                    s[n] = s[n + len_a];
                }
                strlcpy(s + n, attr, len_s - n);
                TR(TRACE_DATABASE, ("to:\n\t%s", s));
            }
        }
        return TRUE;
    }
    return FALSE;		/* oops */
}
예제 #6
0
void FLPCAL(struct STACK *a, int n)
{
   int j;
   if(a!=NULL){
      FLPCAL(a->L,n);
      if(a->data=='.'){
	 if(PRESENT(a->L->LP,n,1)==1)
	    for(j=1;j<=a->R->FP[0];j++)
	       if(PRESENT(flps[n],a->R->FP[j],1)==0){
		  flps[n][1]++;
		  flps[n][flps[n][1]+1]=a->R->FP[j];
	       }
      }
      else if(a->data=='*'){
	 if(PRESENT(a->LP,n,1)==1)
	    for(j=1;j<=a->FP[0];j++)
	      if(PRESENT(flps[n],a->FP[j],1)==0){
		 flps[n][1]++;
		 flps[n][flps[n][1]+1]=a->FP[j];
	      }
      }
      FLPCAL(a->R,n);
   }
}
예제 #7
0
void util_spawn(void)
{

	char buf[256];
	$DESCRIPTOR(d_buf,buf);
	$DESCRIPTOR(d_ent," ");

	d_ent.dsc$a_pointer = "COMMAND";
	d_ent.dsc$w_length = 7;

	if (CLI$PRESENT(&d_ent) == CLI$_PRESENT)
	{
		if (CLI$GET_VALUE(&d_ent,&d_buf) == SS$_NORMAL)
			lib$spawn(&d_buf);
		return;
	}
	d_buf.dsc$w_length = 0;
	lib$spawn(&d_buf);
	return;

}
예제 #8
0
static void
postprocess_terminfo(TERMTYPE * tp)
{
    /*
     * TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
     * ----------------------------------------------------------------------
     */

    /*
     * Translate AIX forms characters.
     */
    if (PRESENT(box_chars_1)) {
	char buf2[MAX_TERMCAP_LENGTH];
	string_desc result;

	_nc_str_init(&result, buf2, sizeof(buf2));
	_nc_safe_strcat(&result, acs_chars);

	append_acs0 (&result, 'l', box_chars_1[0]);	/* ACS_ULCORNER */
	append_acs0 (&result, 'q', box_chars_1[1]);	/* ACS_HLINE */
	append_acs0 (&result, 'k', box_chars_1[2]);	/* ACS_URCORNER */
	append_acs0 (&result, 'x', box_chars_1[3]);	/* ACS_VLINE */
	append_acs0 (&result, 'j', box_chars_1[4]);	/* ACS_LRCORNER */
	append_acs0 (&result, 'm', box_chars_1[5]);	/* ACS_LLCORNER */
	append_acs0 (&result, 'w', box_chars_1[6]);	/* ACS_TTEE */
	append_acs0 (&result, 'u', box_chars_1[7]);	/* ACS_RTEE */
	append_acs0 (&result, 'v', box_chars_1[8]);	/* ACS_BTEE */
	append_acs0 (&result, 't', box_chars_1[9]);	/* ACS_LTEE */
	append_acs0 (&result, 'n', box_chars_1[10]);	/* ACS_PLUS */

	if (buf2[0]) {
	    acs_chars = _nc_save_str(buf2);
	    _nc_warning("acsc string synthesized from AIX capabilities");
	    box_chars_1 = ABSENT_STRING;
	}
    }
    /*
     * ----------------------------------------------------------------------
     */
}
예제 #9
0
파일: trim_sgr0.c 프로젝트: 2asoft/freebsd
_nc_trim_sgr0(TERMTYPE *tp)
{
    char *result = exit_attribute_mode;

    T((T_CALLED("_nc_trim_sgr0()")));

    if (PRESENT(exit_attribute_mode)
	&& PRESENT(set_attributes)) {
	bool found = FALSE;
	char *on = set_attribute_9(tp, 1);
	char *off = set_attribute_9(tp, 0);
	char *end = strdup(exit_attribute_mode);
	char *tmp;
	size_t i, j, k;

	TR(TRACE_DATABASE, ("checking if we can trim sgr0 based on sgr"));
	TR(TRACE_DATABASE, ("sgr0       %s", _nc_visbuf(end)));
	TR(TRACE_DATABASE, ("sgr(9:off) %s", _nc_visbuf(off)));
	TR(TRACE_DATABASE, ("sgr(9:on)  %s", _nc_visbuf(on)));

	if (!rewrite_sgr(on, enter_alt_charset_mode)
	    || !rewrite_sgr(off, exit_alt_charset_mode)
	    || !rewrite_sgr(end, exit_alt_charset_mode)) {
	    FreeIfNeeded(off);
	} else if (similar_sgr(off, end)
		   && !similar_sgr(off, on)) {
	    TR(TRACE_DATABASE, ("adjusting sgr(9:off) : %s", _nc_visbuf(off)));
	    result = off;
	    /*
	     * If rmacs is a substring of sgr(0), remove that chunk.
	     */
	    if (exit_alt_charset_mode != 0) {
		TR(TRACE_DATABASE, ("scan for rmacs %s", _nc_visbuf(exit_alt_charset_mode)));
		j = strlen(off);
		k = strlen(exit_alt_charset_mode);
		if (j > k) {
		    for (i = 0; i <= (j - k); ++i) {
			unsigned k2 = compare_part(exit_alt_charset_mode,
						   off + i);
			if (k2 != 0) {
			    found = TRUE;
			    chop_out(off, (unsigned) i, (unsigned) (i + k2));
			    break;
			}
		    }
		}
	    }
	    /*
	     * SGR 10 would reset to normal font.
	     */
	    if (!found) {
		if ((i = (size_t) is_csi(off)) != 0
		    && off[strlen(off) - 1] == 'm') {
		    TR(TRACE_DATABASE, ("looking for SGR 10 in %s",
					_nc_visbuf(off)));
		    tmp = skip_zero(off + i);
		    if (tmp[0] == '1'
			&& skip_zero(tmp + 1) != tmp + 1) {
			i = (size_t) (tmp - off);
			if (off[i - 1] == ';')
			    i--;
			j = (size_t) (skip_zero(tmp + 1) - off);
			(void) chop_out(off, (unsigned) i, (unsigned) j);
			found = TRUE;
		    }
		}
	    }
	    if (!found
		&& (tmp = strstr(end, off)) != 0
		&& strcmp(end, off) != 0) {
		i = (size_t) (tmp - end);
		j = strlen(off);
		tmp = strdup(end);
		chop_out(tmp, (unsigned) i, (unsigned) j);
		free(off);
		result = tmp;
	    }
	    TR(TRACE_DATABASE, ("...adjusted sgr0 : %s", _nc_visbuf(result)));
	    if (!strcmp(result, exit_attribute_mode)) {
		TR(TRACE_DATABASE, ("...same result, discard"));
		free(result);
		result = exit_attribute_mode;
	    }
	} else {
	    /*
	     * Either the sgr does not reference alternate character set,
	     * or it is incorrect.  That's too hard to decide right now.
	     */
	    free(off);
	}
	FreeIfNeeded(end);
	FreeIfNeeded(on);
    } else {
	/*
	 * Possibly some applications are confused if sgr0 contains rmacs,
	 * but that would be a different bug report -TD
	 */
    }

    returnPtr(result);
}
예제 #10
0
파일: paging.c 프로젝트: Marlinc/andromeda
/**
 * Called when a pagefault occurs, is in charge of fixing the fault and swapping
 * if necessary.
 */
void cPageFault(isrVal_t registers)
{
	addr_t page = getCR2();
	addr_t page_addr = page & ~(0xFFF);

#ifdef PAGEDBG
	printf("PG!\n");
	printf("Fault addr: %X\nPage index: %X\n", page, page_addr);
	printf("Fault type: %X\n", registers.errCode);
	printf("EIP: %X\nESP: %X\nESP: %X\n",
			       registers.eip, registers.procesp, registers.esp);
	printf("eax: %X\tebx: %X\necx: %X\tedx: %X\n",
		    registers.eax, registers.ebx, registers.ecx, registers.edx);
#endif

	if (registers.cs != 0x8 && registers.cs != 0x18)
		panic("Incorrect frame!");
	if (USER(registers.errCode))
		panic("Userspace isn't implemented yet!");
	if (RESERVED(registers.errCode))
		panic("A reserved bit has been set!\n");
	if (PRESENT(registers.errCode))
		panic("Illegal operation!");

	addr_t pd = getPageDir();

	/**
	* The data bit only works if a specific bit is set. See intel docs volume 3
	* for more information.
	*/

	if (DATA(registers.errCode))
	{
#ifdef PAGEDBG
		printf("Trying to access unimplemented data!\n");
#endif
		if (WRITE(registers.errCode))
		{
#ifdef PAGEDBG
		printf("Faulted a write attempt!\n");
		printf("Adding page!\n");
#endif
		if (USER(registers.errCode))
		{
			//Add a user page!
		}
		else
		{
#ifdef PAGEDBG
			printf("Adding a kernel page!\n");
#endif
			if (idx_kernel_space == MAP_NOMAP)
				panic("Kernel page map not correctly initialised!");

			int ret = page_alloc_page
				(idx_kernel_space, page_addr, (void*)pd, FALSE);
			if (ret != -E_SUCCESS)
			{
				printf("ERRCODE: %X\n", -ret);
				panic("Couldn't alloc page!");
			}
#ifdef PAGEDBG
			printf("Phys of %X = %X\n", page, page_phys_addr(page, (void*)pd));
#endif
			}
		}
		else
		{
#ifdef PAGEDBG
			printf("Faulted a read attempt!\n");
#endif
			// Assume the page may be read!
			if (idx_kernel_space == MAP_NOMAP)
			    panic("Kernel page map not correctly initialised!");
			int ret = page_alloc_page(idx_kernel_space, page_addr,
							      (void*)pd, FALSE);
			if (ret != -E_SUCCESS)
			{
				printf("ERRCODE: %X\n", -ret);
				panic("Couldn't alloc page!");
			}
#ifdef PAGEDBG
			printf("Phys of %X = %X\n", page, page_phys_addr(page, (void*)pd));
#endif
		}
	}
	else
	{
#ifdef PAGEDBG
	panic("Trying to run unimplemented code!\n");
#endif
	}
#ifdef UNDEFINED
	printf("Page faults currently under construction!\n");
#endif
}
예제 #11
0
static void
postprocess_termcap(TERMTYPE * tp, bool has_base)
{
    char buf[MAX_LINE * 2 + 2];
    string_desc result;

    /*
     * TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS
     *
     * This first part of the code is the functional inverse of the
     * fragment in capdefaults.c.
     * ----------------------------------------------------------------------
     */

    /* if there was a tc entry, assume we picked up defaults via that */
    if (!has_base) {
	if (WANTED(init_3string) && termcap_init2)
	    init_3string = _nc_save_str(termcap_init2);

	if (WANTED(reset_2string) && termcap_reset)
	    reset_2string = _nc_save_str(termcap_reset);

	if (WANTED(carriage_return)) {
	    if (carriage_return_delay > 0) {
		sprintf(buf, "%s$<%d>", C_CR, carriage_return_delay);
		carriage_return = _nc_save_str(buf);
	    } else
		carriage_return = _nc_save_str(C_CR);
	}
	if (WANTED(cursor_left)) {
	    if (backspace_delay > 0) {
		sprintf(buf, "%s$<%d>", C_BS, backspace_delay);
		cursor_left = _nc_save_str(buf);
	    } else if (backspaces_with_bs == 1)
		cursor_left = _nc_save_str(C_BS);
	    else if (PRESENT(backspace_if_not_bs))
		cursor_left = backspace_if_not_bs;
	}
	/* vi doesn't use "do", but it does seems to use nl (or '\n') instead */
	if (WANTED(cursor_down)) {
	    if (PRESENT(linefeed_if_not_lf))
		cursor_down = linefeed_if_not_lf;
	    else if (linefeed_is_newline != 1) {
		if (new_line_delay > 0) {
		    sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
		    cursor_down = _nc_save_str(buf);
		} else
		    cursor_down = _nc_save_str(C_LF);
	    }
	}
	if (WANTED(scroll_forward) && crt_no_scrolling != 1) {
	    if (PRESENT(linefeed_if_not_lf))
		cursor_down = linefeed_if_not_lf;
	    else if (linefeed_is_newline != 1) {
		if (new_line_delay > 0) {
		    sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
		    scroll_forward = _nc_save_str(buf);
		} else
		    scroll_forward = _nc_save_str(C_LF);
	    }
	}
	if (WANTED(newline)) {
	    if (linefeed_is_newline == 1) {
		if (new_line_delay > 0) {
		    sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
		    newline = _nc_save_str(buf);
		} else
		    newline = _nc_save_str(C_LF);
	    } else if (PRESENT(carriage_return) && PRESENT(scroll_forward)) {
		_nc_str_init(&result, buf, sizeof(buf));
		if (_nc_safe_strcat(&result, carriage_return)
		 && _nc_safe_strcat(&result, scroll_forward))
		    newline = _nc_save_str(buf);
	    } else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {
		_nc_str_init(&result, buf, sizeof(buf));
		if (_nc_safe_strcat(&result, carriage_return)
		 && _nc_safe_strcat(&result, cursor_down))
		    newline = _nc_save_str(buf);
	    }
	}
    }

    /*
     * Inverse of capdefaults.c code ends here.
     * ----------------------------------------------------------------------
     *
     * TERMCAP-TO TERMINFO MAPPINGS FOR SOURCE TRANSLATION
     *
     * These translations will *not* be inverted by tgetent().
     */

    if (!has_base) {
	/*
	 * We wait until now to decide if we've got a working cr because even
	 * one that doesn't work can be used for newline. Unfortunately the
	 * space allocated for it is wasted.
	 */
	if (return_does_clr_eol == 1 || no_correctly_working_cr == 1)
	    carriage_return = ABSENT_STRING;

	/*
	 * Supposedly most termcap entries have ta now and '\t' is no longer a
	 * default, but it doesn't seem to be true...
	 */
	if (WANTED(tab)) {
	    if (horizontal_tab_delay > 0) {
		sprintf(buf, "%s$<%d>", C_HT, horizontal_tab_delay);
		tab = _nc_save_str(buf);
	    } else
		tab = _nc_save_str(C_HT);
	}
	if (init_tabs == ABSENT_NUMERIC && has_hardware_tabs == TRUE)
	    init_tabs = 8;

	/*
	 * Assume we can beep with ^G unless we're given bl@.
	 */
	if (WANTED(bell))
	    bell = _nc_save_str("\007");
    }

    /*
     * Translate the old termcap :pt: capability to it#8 + ht=\t
     */
    if (has_hardware_tabs == TRUE) {
	if (init_tabs != 8 && init_tabs != ABSENT_NUMERIC)
	    _nc_warning("hardware tabs with a width other than 8: %d", init_tabs);
	else {
	    if (tab && _nc_capcmp(tab, C_HT))
		_nc_warning("hardware tabs with a non-^I tab string %s",
			    _nc_visbuf(tab));
	    else {
		if (WANTED(tab))
		    tab = _nc_save_str(C_HT);
		init_tabs = 8;
	    }
	}
    }
    /*
     * Now translate the ko capability, if there is one.  This
     * isn't from mytinfo...
     */
    if (PRESENT(other_non_function_keys)) {
	char *base = other_non_function_keys;
	char *bp, *cp, *dp;
	struct name_table_entry const *from_ptr;
	struct name_table_entry const *to_ptr;
	assoc const *ap;
	char buf2[MAX_TERMINFO_LENGTH];
	bool foundim;

	/* we're going to use this for a special case later */
	dp = strchr(other_non_function_keys, 'i');
	foundim = (dp != 0) && (dp[1] == 'm');

	/* look at each comma-separated capability in the ko string... */
	for (base = other_non_function_keys;
	     (cp = strchr(base, ',')) != 0;
	     base = cp + 1) {
	    size_t len = cp - base;

	    for (ap = ko_xlate; ap->from; ap++)
		if (len == strlen(ap->from)
		    && strncmp(ap->from, base, len) == 0)
		    break;
	    if (!ap->to) {
		_nc_warning("unknown capability `%.*s' in ko string",
			    (int) len, base);
		continue;
	    } else if (ap->to == CANCELLED_STRING)	/* ignore it */
		continue;

	    /* now we know we found a match in ko_table, so... */

	    from_ptr = _nc_find_entry(ap->from, _nc_cap_hash_table);
	    to_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);

	    if (!from_ptr || !to_ptr)	/* should never happen! */
		_nc_err_abort("ko translation table is invalid, I give up");

	    if (WANTED(tp->Strings[from_ptr->nte_index])) {
		_nc_warning("no value for ko capability %s", ap->from);
		continue;
	    }

	    if (tp->Strings[to_ptr->nte_index]) {
		/* There's no point in warning about it if it's the same
		 * string; that's just an inefficiency.
		 */
		if (strcmp(
			      tp->Strings[from_ptr->nte_index],
			      tp->Strings[to_ptr->nte_index]) != 0)
		    _nc_warning("%s (%s) already has an explicit value %s, ignoring ko",
				ap->to, ap->from,
				_nc_visbuf(tp->Strings[to_ptr->nte_index]));
		continue;
	    }

	    /*
	     * The magic moment -- copy the mapped key string over,
	     * stripping out padding.
	     */
	    for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) {
		if (bp[0] == '$' && bp[1] == '<') {
		    while (*bp && *bp != '>') {
			++bp;
		    }
		} else
		    *dp++ = *bp;
	    }
	    *dp++ = '\0';

	    tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
	}

	/*
	 * Note: ko=im and ko=ic both want to grab the `Insert'
	 * keycap.  There's a kich1 but no ksmir, so the ic capability
	 * got mapped to kich1 and im to kIC to avoid a collision.
	 * If the description has im but not ic, hack kIC back to kich1.
	 */
	if (foundim && WANTED(key_ic) && key_sic) {
	    key_ic = key_sic;
	    key_sic = ABSENT_STRING;
	}
    }

    if (!hard_copy) {
	if (WANTED(key_backspace))
	    key_backspace = _nc_save_str(C_BS);
	if (WANTED(key_left))
	    key_left = _nc_save_str(C_BS);
	if (WANTED(key_down))
	    key_down = _nc_save_str(C_LF);
    }

    /*
     * Translate XENIX forms characters.
     */
    if (PRESENT(acs_ulcorner) ||
	PRESENT(acs_llcorner) ||
	PRESENT(acs_urcorner) ||
	PRESENT(acs_lrcorner) ||
	PRESENT(acs_ltee) ||
	PRESENT(acs_rtee) ||
	PRESENT(acs_btee) ||
	PRESENT(acs_ttee) ||
	PRESENT(acs_hline) ||
	PRESENT(acs_vline) ||
	PRESENT(acs_plus)) {
	char buf2[MAX_TERMCAP_LENGTH];

	_nc_str_init(&result, buf2, sizeof(buf2));
	_nc_safe_strcat(&result, acs_chars);

	append_acs (&result, 'j', acs_lrcorner);
	append_acs (&result, 'k', acs_urcorner);
	append_acs (&result, 'l', acs_ulcorner);
	append_acs (&result, 'm', acs_llcorner);
	append_acs (&result, 'n', acs_plus);
	append_acs (&result, 'q', acs_hline);
	append_acs (&result, 't', acs_ltee);
	append_acs (&result, 'u', acs_rtee);
	append_acs (&result, 'v', acs_btee);
	append_acs (&result, 'w', acs_ttee);
	append_acs (&result, 'x', acs_vline);

	if (buf2[0]) {
	    acs_chars = _nc_save_str(buf2);
	    _nc_warning("acsc string synthesized from XENIX capabilities");
	}
    } else if (acs_chars == 0
	       && enter_alt_charset_mode != 0
	       && exit_alt_charset_mode != 0) {
	acs_chars =
	    _nc_save_str("``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~");
    }
}
예제 #12
0
/**
 * Returns page allocated for that virtual address.
 *
 * If allocate_new is specified to true, it will allocate substructures,
 * if not present.Otherwise returns NULL if page structures are not present
 * on the way to the virtual address. Returned pointer points to page in page
 * table.
 */
static puint_t* __get_page(uintptr_t vaddress, uintptr_t cr3, bool allocate_new, bool user) {

    v_address_t va;
    memcpy(&va, &vaddress, 8);

    puint_t* pml4 = (puint_t*)ALIGN(physical_to_virtual(cr3));
    if (!PRESENT(pml4[va.pml])) {
        if (!allocate_new) {
            return 0;
        }
        pdpt_t pdpt;
        memset(&pdpt, 0, sizeof(pdpt_t));
        pdpt.number = get_free_frame();
        if (pdpt.number == 0)
            return 0;
        pdpt.flaggable.present = 1;
        pdpt.flaggable.us = user;
        pdpt.flaggable.rw = 1;
        pml4[va.pml] = pdpt.number;
        memset((void*)physical_to_virtual(ALIGN(pdpt.number)), 0, 0x1000);
    }

    puint_t* pdpt = (puint_t*)ALIGN(physical_to_virtual(pml4[va.pml]));

    if (!PRESENT(pdpt[va.directory_ptr])) {
        if (!allocate_new)
            return 0;
        page_directory_t dir;
        memset(&dir, 0, sizeof(page_directory_t));
        dir.number = get_free_frame();
        if (dir.number == 0) {
            return 0;
        }
        dir.flaggable.present = 1;
        dir.flaggable.us = user;
        dir.flaggable.rw = 1;
        pdpt[va.directory_ptr] = dir.number;
        memset((void*)physical_to_virtual(ALIGN(dir.number)), 0, 0x1000);
    }

    puint_t* pdir = (puint_t*)ALIGN(physical_to_virtual(pdpt[va.directory_ptr]));

    if (!PRESENT(pdir[va.directory])) {
        if (!allocate_new)
            return 0;
        page_table_t pt;
        memset(&pt, 0, sizeof(page_table_t));
        pt.number = get_free_frame();
        if (pt.number == 0) {
            return 0;
        }
        pt.flaggable.present = 1;
        pt.flaggable.us = user;
        pt.flaggable.rw = 1;
        pdir[va.directory] = pt.number;
        memset((void*)physical_to_virtual(ALIGN(pt.number)), 0, 0x1000);
    }

    puint_t* pt = (puint_t*)ALIGN(physical_to_virtual(pdir[va.directory]));
    return &pt[va.table];
}
예제 #13
0
OBJECT *
vmm_vaddr_to_memobj(PROCESS *prp, void *addr, unsigned *offset, int mark_page) {
	uint32_t		*pde;
	uint32_t		pte;
	unsigned		pg_offset;
	paddr_t			paddr;
	uintptr_t		vaddr = (uintptr_t)addr;
	ADDRESS			*adp;
	unsigned		mask;

	/* piece of cake for P1, P2 addresses */
	if(SH_IS_P1(vaddr) || SH_IS_P2(vaddr)) {
		// Assuming P1 & P2 are the same size
		paddr = vaddr & (SH_P1SIZE - 1);
		*offset = PADDR_TO_SYNC_OFF(paddr);
		return PADDR_TO_SYNC_OBJ(paddr);
	}

	pg_offset = ADDR_OFFSET(vaddr);

	// Check for system, cpu pages...
	if(ADDR_PAGE(vaddr) == SYSP_ADDCOLOR(VM_CPUPAGE_ADDR, SYSP_GETCOLOR(_cpupage_ptr))) {
		paddr = SH_P1_TO_PHYS((uintptr_t)_cpupage_ptr) | pg_offset;
		*offset = PADDR_TO_SYNC_OFF(paddr);
		return PADDR_TO_SYNC_OBJ(paddr);
	}

	if(ADDR_PAGE(vaddr) == SYSP_ADDCOLOR(VM_SYSPAGE_ADDR, SYSP_GETCOLOR(_syspage_ptr))) {
		paddr = SH_P1_TO_PHYS((uintptr_t)_syspage_ptr) | pg_offset;
		*offset = PADDR_TO_SYNC_OFF(paddr);
		return PADDR_TO_SYNC_OBJ(paddr);
	}

#ifndef NDEBUG
	if(prp == NULL) crash();
#endif
	adp = prp->memory;
#ifndef NDEBUG
	if(adp == NULL) crash();
#endif

	pde = adp->cpu.pgdir[L1PAGEIDX(vaddr)];

	if((pde == NULL) || !PRESENT((pte = pde[L2PAGEIDX(vaddr)]))) {
		/* not mapped, check for perm mappings */
		goto fail;
	}

	mask = SH_PTE_PGSIZE_MASK(pte);
	paddr = (pte & mask) | (vaddr & ~mask);

	if(mark_page) {
		struct pa_quantum	*pq;
		pq = pa_paddr_to_quantum(paddr);
		if(pq != NULL) {
			pq->flags |= PAQ_FLAG_HAS_SYNC;
		}
	}

	*offset = PADDR_TO_SYNC_OFF(paddr);
	return PADDR_TO_SYNC_OBJ(paddr);

fail:
#ifndef NDEBUG
	crash();
	/* NOTREACHED */
#endif
	return (OBJECT *)-1;
}
예제 #14
0
void DFA()
{
   int i,j,k,l,m,fg,find;
   int tmp[10], newn[10];
   node[0][0]=1;
   node[1][0]='A';
   node[1][1]=0;
   for(i=1;i<=O->D->FP[0];i++){
       node[1][1]++;
       node[1][node[1][1]+1]=O->D->FP[i];
   }
   DF[0][0]=var-1;
   for(i=1;i<var;i++)
      DF[0][i]=position[i-1][0];
   for(i=1;i<=node[0][0];i++){
       DF[i][0]=node[i][0];
       for(j=1;j<=DF[0][0];j++){
	   tmp[0]=0;
	   newn[0]=0;
	   for(k=2;k<=node[i][1]+1;k++){
	       if(PRESENT(position[j-1],node[i][k],2)==1)
		  tmp[++tmp[0]]=node[i][k];
		  for(l=1;l<=tmp[0];l++){
		     for(m=2;m<=flps[tmp[l]][1]+1;m++)
			if(PRESENT(newn,flps[tmp[l]][m],1)==0){
			   newn[0]++;
			   newn[newn[0]]=flps[tmp[l]][m];
			}
		  }
	   }
	   printf(" ");
	   fg=0;
	   for(l=1;l<=node[0][0];l++){
	       find=0;
	       if(newn[0]==node[l][1])
		  for(k=1;k<=newn[0];k++)
		     if(PRESENT(node[l],newn[k],2)==0)
			  fg=1;
		     else find++;
		  if(find==newn[0]&&find!=0)
		     goto l1;
	   }
	   if(newn[0]==0){
	      DF[i][j]='-';
	      goto l2;
	   }
	   node[0][0]++;
	   node[node[0][0]][0]=node[node[0][0]-1][0]+1;
	   for(m=0;m<=newn[0];m++)
	      node[node[0][0]][m+1]=newn[m];
	   DF[i][j]=node[node[0][0]][0];
	   goto l2;
l1:       DF[i][j]=node[l][0];
l2:      if(fg==1||fg==0)  printf(" ");
       }
   }
   printf("\n\nNODES:\n\n");
   for(i=1;i<=node[0][0];i++,printf("\n\n"))
      for(j=0;j<=node[i][1]+1;j++)
	 if(j==0)
	    printf(" %c ",node[i][j]);
	 else if(j==1)
	    printf(" => ");
	 else
	    printf(" %d ",node[i][j]);
   printf("\n\nDFA TABLE:\n\n");
   for(i=0;i<=node[0][0];i++,printf("\n\n"))
      for(j=0;j<=DF[0][0];j++)
	  if(i==0&&j==0)
	     printf("    ");
	  else
	     printf("%4c",DF[i][j]);
}
예제 #15
0
void FP_LP_CAL(struct STACK *a)
{
   if(a!=NULL){
      int i, flg;
      FP_LP_CAL(a->L);
      FP_LP_CAL(a->R);
      if(a->data!='+'&&a->data!='.'&&a->data!='*'){
	 a->FP[0]++; a->LP[0]++;
	 a->FP[a->FP[0]]=terp;
	 a->LP[a->LP[0]]=terp++;
	 flg=0;
	 for(i=0;i<var;i++)
	   if(position[i][0]==a->data){
	      position[i][1]++;
	      position[i][position[i][1]+1]=terp-1;
	      flg=1;
	   }
	   if(flg==0){
	      position[var++][1]=1;
	      position[var-1][2]=terp-1;
	      position[var-1][0]=a->data;
	   }
	 }
	 else if(a->data=='+'){
	   for(i=1;i<=a->L->FP[0];i++){
	       a->FP[0]++;
	       a->FP[a->FP[0]]=a->L->FP[i];
	   }
	   for(i=1;i<=a->R->FP[0];i++){
	     if(PRESENT(a->FP, a->R->FP[i],1)==0){
		a->FP[0]++;
		a->FP[a->FP[0]]=a->R->FP[i];
	     }
	   }
	   for(i=1;i<=a->L->LP[0];i++){
	       a->LP[0]++;
	       a->LP[a->LP[0]]=a->L->LP[i];
	   }
	   for(i=1;i<=a->R->LP[0];i++)
	      if(PRESENT(a->LP, a->R->LP[i], 1)==0){
		 a->LP[0]++;
		 a->LP[a->LP[0]]=a->R->LP[i];
	      }
	 }
	 else if(a->data=='*'){
	   for(i=1;i<=a->L->FP[0];i++){
	       a->FP[0]++;
	       a->FP[a->FP[0]]=a->L->FP[i];
	   }
	   for(i=1;i<=a->L->LP[0];i++){
	       a->LP[0]++;
	       a->LP[a->LP[0]]=a->L->LP[i];
	   }
	 }
	 else if(a->data=='.'){
	 //firstpos
	    for(i=1;i<=a->L->FP[0];i++){
		a->FP[0]++;
		a->FP[a->FP[0]]=a->L->FP[i];
	    }
	    if(a->L->data=='*')
	      for(i=1;i<=a->R->FP[0];i++)
		 if(PRESENT(a->FP, a->R->FP[i],1)==0){
		    a->FP[0]++;
		    a->FP[a->FP[0]]=a->R->FP[i];
		 }
	 //lastpos
	    for(i=1;i<=a->R->LP[0];i++){
		a->LP[0]++;
		a->LP[a->LP[0]]=a->R->LP[i];
	    }
	    if(a->R->data=='*')
	    for(i=1;i<=a->L->LP[0];i++)
		if(PRESENT(a->LP,a->L->LP[i],1)==0){
		  a->LP[0]++;
		  a->LP[a->LP[0]]=a->L->LP[i];
		}
	 }
   }
}
예제 #16
0
파일: parse_entry.c 프로젝트: vocho/openqnx
static
void postprocess_terminfo(TERMTYPE *tp)
{
    /*
     * TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
     * ----------------------------------------------------------------------
     */

    /*
     * Translate AIX forms characters.
     */
    if (PRESENT(box_chars_1))
    {
	char	buf2[MAX_TERMCAP_LENGTH], *bp = buf2;

	if (acs_chars)
	{
	    (void)strcpy(bp, acs_chars);
	    bp += strlen(bp);
	}

	if (box_chars_1[0])	/* ACS_ULCORNER */
	{
	    *bp++ = 'l';
	    *bp++ = box_chars_1[0];
	}
	if (box_chars_1[1])	/* ACS_HLINE */
	{
	    *bp++ = 'q';
	    *bp++ = box_chars_1[1];
	}
	if (box_chars_1[2])	/* ACS_URCORNER */
	{
	    *bp++ = 'k';
	    *bp++ = box_chars_1[2];
	}
	if (box_chars_1[3])	/* ACS_VLINE */
	{
	    *bp++ = 'x';
	    *bp++ = box_chars_1[3];
	}
	if (box_chars_1[4])	/* ACS_LRCORNER */
	{
	    *bp++ = 'j';
	    *bp++ = box_chars_1[4];
	}
	if (box_chars_1[5])	/* ACS_LLCORNER */
	{
	    *bp++ = 'm';
	    *bp++ = box_chars_1[5];
	}
	if (box_chars_1[6])	/* ACS_TTEE */
	{
	    *bp++ = 'w';
	    *bp++ = box_chars_1[6];
	}
	if (box_chars_1[7])	/* ACS_RTEE */
	{
	    *bp++ = 'u';
	    *bp++ = box_chars_1[7];
	}
	if (box_chars_1[8])	/* ACS_BTEE */
	{
	    *bp++ = 'v';
	    *bp++ = box_chars_1[8];
	}
	if (box_chars_1[9])	/* ACS_LTEE */
	{
	    *bp++ = 't';
	    *bp++ = box_chars_1[9];
	}
	if (box_chars_1[10])	/* ACS_PLUS */
	{
	    *bp++ = 'n';
	    *bp++ = box_chars_1[10];
	}

	if (bp != buf2)
	{
	    *bp++ = '\0';
	    acs_chars = _nc_save_str(buf2);
	    _nc_warning("acsc string synthesized from AIX capabilities");
	    box_chars_1 = ABSENT_STRING;
	}
    }
    /*
     * ----------------------------------------------------------------------
     */
}