Ejemplo n.º 1
0
/**
 * "switch" statement
 */
doswitch() {
        loop_t loop;
        loop_t *ptr;

        loop.symbol_idx = local_table_index;
        loop.stack_pointer = stkp;
        loop.type = WSSWITCH;
        loop.test_label = swstp;
        loop.body_label = getlabel ();
        loop.cont_label = loop.exit_label = getlabel ();
        addloop (&loop);
        gen_immediate_a ();
        print_label (loop.body_label);
        newline ();
        gen_push ();
        needbrack ("(");
        expression (YES);
        needbrack (")");
        stkp = stkp + INTSIZE;  // '?case' will adjust the stack
        gen_jump_case ();
        statement (NO);
        ptr = readswitch ();
        gen_jump (ptr->exit_label);
        dumpsw (ptr);
        generate_label (ptr->exit_label);
        local_table_index = ptr->symbol_idx;
        stkp = gen_modify_stack (ptr->stack_pointer);
        swstp = ptr->test_label;
        delloop ();
}
Ejemplo n.º 2
0
/**
 * "switch" statement
 */
void doswitch(void) {
        WHILE ws;
        WHILE *ptr;

        ws.symbol_idx = local_table_index;
        ws.stack_pointer = stkp;
        ws.type = WSSWITCH;
        ws.case_test = swstp;
        ws.body_tab = getlabel ();
        ws.incr_def = ws.while_exit = getlabel ();
        addwhile (&ws);
        gen_immediate ();
        print_label (ws.body_tab);
        newline ();
        gen_push (HL_REG);
        needbrack ("(");
        expression (YES);
        needbrack (")");
        stkp = stkp + INTSIZE;  // '?case' will adjust the stack
        gen_jump_case ();
        statement (NO);
        ptr = readswitch ();
        gen_jump (ptr->while_exit);
        dumpsw (ptr);
        generate_label (ptr->while_exit);
        local_table_index = ptr->symbol_idx;
        stkp = gen_modify_stack (ptr->stack_pointer);
        swstp = ptr->case_test;
        delwhile ();
}
Ejemplo n.º 3
0
/*
 *	"switch" statement
 */
void doswitch (void )
{
	INTPTR_T	ws[7];
	INTPTR_T	*ptr;

	ws[WSSYM] = (INTPTR_T)locptr;
	ws[WSSP] = stkp;
	ws[WSTYP] = WSSWITCH;
	ws[WSCASEP] = swstp;
	ws[WSTAB] = getlabel ();
	ws[WSDEF] = ws[WSEXIT] = getlabel ();
	addwhile (ws);
	immed (T_LABEL, ws[WSTAB]);
	gpush ();
	needbrack ("(");
	expression (YES);
	needbrack (")");
	stkp = stkp + INTSIZE;  /* '?case' will adjust the stack */
	gjcase ();
	statement (NO);
	ptr = readswitch ();
	jump (ptr[WSEXIT]);
	dumpsw (ptr);
	gnlabel (ptr[WSEXIT]);
	locptr = (char*)ptr[WSSYM];
	stkp = modstk (ptr[WSSP]);
	swstp = ptr[WSCASEP];
	delwhile ();
}
Ejemplo n.º 4
0
/**
 * evaluate one initializer, add data to table
 * @param symbol_name
 * @param type
 * @param identity
 * @param dim
 * @param tag
 * @return
 *	returns size of initializer, or 0 for none (a null string is size 1)
 *
 */
int init(char *symbol_name, int type, int identity, int *dim, TAG_SYMBOL *tag) {
    int value, n;

    /* A pointer is initialized as a word holding the address of the struct
       or string etc that directly follows */
    if(identity == POINTER) {
        int x = getlabel();
        gen_def_word();
        print_label(x);
        newline();
        print_label(x);
        output_label_terminator();
        newline();
    }
    /* FIXME: may need to distinguish const string v data in future */
    if(quoted_string(&n, NULL)) {
        if((identity == VARIABLE) || !(type & CCHAR))
            error("found string: must assign to char pointer or array");
        *dim = *dim - n; /* ??? FIXME arrays of char only */
        return n;
    }

    if (type & CCHAR)
        gen_def_byte();
    else
        gen_def_word();
    if (!number(&value) && !quoted_char(&value))
        return 0;
    *dim = *dim - 1;
    output_number(value);
    newline();
    return (type & CCHAR) ? 1 : 2;
}
Ejemplo n.º 5
0
/**
 * add new symbol to local table
 * @param sname
 * @param identity
 * @param type
 * @param offset size in bytes
 * @param storage_class
 * @return 
 */
int add_local (char *sname, int identity, int type, int offset, int storage_class) {
    int k;
    SYMBOL *symbol;
    char *buffer_ptr;

    if ((current_symbol_table_idx = find_locale (sname)) > -1) {
        return (current_symbol_table_idx);
    }
    if (local_table_index >= NUMBER_OF_GLOBALS + NUMBER_OF_LOCALS) {
        error ("local symbol table overflow");
        return (0);
    }
    current_symbol_table_idx = local_table_index;
    symbol = &symbol_table[current_symbol_table_idx];
    buffer_ptr = symbol->name;
    /* FIXME: only copy so many bytes */
    while (alphanumeric(*buffer_ptr++ = *sname++));
    symbol->identity = identity;
    symbol->type = type;
    symbol->storage = storage_class;
    if (storage_class == LSTATIC) {
        data_segment_gdata();
        print_label(k = getlabel());
        output_label_terminator();
        gen_def_storage();
        output_number(offset);
        newline();
        code_segment_gtext();
        offset = k;
    }
    symbol->offset = offset;
    local_table_index++;
    return (current_symbol_table_idx);
}
Ejemplo n.º 6
0
Archivo: sc4.c Proyecto: glockwork/dfu
/* Address of the source must already have been loaded in PRI, the
 * destination address in ALT.
 * This routine makes a loop that copies the minor dimension vector
 * by vector.
 */
SC_FUNC void copyarray2d(int majordim,int minordim)
{
  int looplbl=getlabel();

  stgwrite("\tpush.alt\n");
  stgwrite("\tpush.pri\n");
  stgwrite("\tzero.alt\n"); /* ALT = index = 0 */
  setlabel(looplbl);
  stgwrite("\tpush.alt\n"); /* save index */
  stgwrite("\tpick 8\n");   /* PRI = dest */
  stgwrite("\txchg\n");     /* ALT = dest, PRI = index */
  stgwrite("\tidxaddr\n");  /* PRI = dest + index * sizeof(cell) */
  stgwrite("\tmove.alt\n"); /* ALT = dest + index * sizeof(cell) */
  stgwrite("\tload.i\n");   /* PRI = dest[index * sizeof(cell)] */
  stgwrite("\tadd\n");      /* PRI = dest + index * sizeof(cell) + dest[index * sizeof(cell)] */
  stgwrite("\tpush.pri\n");
  stgwrite("\tpick 8\n");   /* PRI = source */
  stgwrite("\tmove.alt\n"); /* ALT = source */
  stgwrite("\tpick 4\n");   /* PRI = index */
  stgwrite("\tidxaddr\n");  /* PRI = source + index * sizeof(cell) */
  stgwrite("\tmove.alt\n"); /* ALT = source + index * sizeof(cell) */
  stgwrite("\tload.i\n");   /* PRI = source[index * sizeof(cell)] */
  stgwrite("\tadd\n");      /* PRI = source + index * sizeof(cell) + source[index * sizeof(cell)] */
  stgwrite("\tpop.alt\n");  /* ALT = source + index * sizeof(cell) + source[index * sizeof(cell)] */
  stgwrite("\tmovs "); outval(minordim*sizeof(cell),TRUE,TRUE);
  stgwrite("\tpop.alt\n");  /* ALT = saved index */
  stgwrite("\tinc.alt\n");  /* ALT = index + 1 */
  stgwrite("\teq.c.alt "); outval(majordim,TRUE,TRUE);
  stgwrite("\tjzer "); outval(looplbl,TRUE,TRUE);
  stgwrite("\tpop.pri\n");  /* restore stack & registers */
  stgwrite("\tpop.alt\n");

  code_idx+=opcodes(26)+opargs(6);
}
Ejemplo n.º 7
0
// Function Draw
// Draws 2-input AND gate
void AND2::Draw(Output* pOut)
{
	//Call output class and pass gate drawing info to it.
	pOut->DrawAND2(m_GfxInfo,getHI()); //feryal
	pOut->Clear_string_from_D_A(m_GfxInfo.x1, m_GfxInfo.y1 - 20);
	pOut->Printstring_in_D_A(getlabel(), pOut, m_GfxInfo.x1, m_GfxInfo.y1 - 20);
}
Ejemplo n.º 8
0
Archivo: goto.c Proyecto: z88dk/z88dk
int dolabel()
{
    int savelptr;
    char sname[NAMESIZE];
    SYMBOL* ptr;
    blanks();
    savelptr = lptr;
    if (symname(sname)) {
        if (gch() == ':') {
            if ((ptr = findgoto(sname)) && ptr->ident == ID_GOTOLABEL) {
                /* Label already goto'd, find some others with
                                 * same stack
                                 */
                debug(DBG_GOTO, "Starting chase %s\n", sname);
                ChaseGoto(ptr);
                ptr->type = KIND_PTR;
            } else {
                ptr = addgotosym(sname);
                ptr->type = KIND_PTR;
            }
            debug(DBG_GOTO, "Adding label not called %s\n", sname);
            ptr->offset.i = Zsp; /* Save stack for label */
            postlabel(ptr->size = getlabel());
            return (1);
        }
    }
    lptr = savelptr;
    return (0);
}
Ejemplo n.º 9
0
void comparator(char op){
	bool eq = false;
	if(look == '='){
		eq = true;
		match("=");
	}
	
	term();

	emitln("cmp ebx, eax");
	
	char* lbltrue = getlabel();
	char* lblend = getlabel();

	if(eq)
		switch(op){
			case '>':
				emitln("jge %s", lbltrue);
				break;
			case '<':
				emitln("jle %s", lbltrue);
				break;
			case '=':
				emitln("je %s", lbltrue);
				break;
			default:
				error("Fatal comparator");
		}

	else
		switch(op){
			case '>':
				emitln("jg %s", lbltrue);
				break;
			case '<':
				emitln("jl %s", lbltrue);
				break;
			default:
				error("Use of assignment operator in comparison");
		}
	
	emitln("xor eax, eax");
	emitln("jmp %s", lblend);
	putlabel(lbltrue);
	emitln("mov eax, 1");
	putlabel(lblend);
}
Ejemplo n.º 10
0
/**
 * compile one file if filename is NULL redirect do to stdin/stdout
 * @param file filename
 * @return 
 */
void compile(char *file) {
    if (file == NULL || filename_typeof(file) == 'c') {
        global_table_index = 0;
        local_table_index = NUMBER_OF_GLOBALS;
        while_table_index = 0;
        tag_table_index = 0;
        inclsp =
        iflevel =
        skiplevel =
        swstp =
        litptr =
        stkp =
        errcnt =
        ncmp =
        lastst =
        //quote[1] =
        0;
        input2 = -1;
        //quote[0] = '"';
        cmode = 1;
        glbflag = 1;
        nxtlab = 0;
        litlab = getlabel();
        defmac("end\tmemory");
        //add_global("memory", ARRAY, CCHAR, 0, EXTERN);
        //add_global("stack", ARRAY, CCHAR, 0, EXTERN);
        rglobal_table_index = global_table_index; //rglbptr = glbptr;
        //add_global("etext", ARRAY, CCHAR, 0, EXTERN);
        //add_global("edata", ARRAY, CCHAR, 0, EXTERN);
        defmac("short\tint");
        initmac();
        // compiler body
        if (file == NULL) {
            input = 0;
        } else if (!openin(file))
            return;
        if (file == NULL) {
            output = 1;
        } else if (!openout())
            return;
        header();
        code_segment_gtext();
        parse();
        close(input);
        data_segment_gdata();
        dumplits();
        dumpglbs();
        errorsummary();
        trailer();
        oflush();
        close(output);
        pl("");
        errs = errs || errfile;
    } else {
        writee("Don't understand file ");
        writee(file);
        errs = 1;
    }
}
Ejemplo n.º 11
0
/**
 * "while" statement
 */
dowhile() {
        loop_t loop;

        loop.symbol_idx = local_table_index;
        loop.stack_pointer = stkp;
        loop.type = WSWHILE;
        loop.test_label = getlabel ();
        loop.exit_label = getlabel ();
        addloop (&loop);
        generate_label (loop.test_label);
        test (loop.exit_label, FALSE);
        statement (NO);
        gen_jump (loop.test_label);
        generate_label (loop.exit_label);
        local_table_index = loop.symbol_idx;
        stkp = gen_modify_stack (loop.stack_pointer);
        delloop ();
}
Ejemplo n.º 12
0
/**
 * "while" statement
 */
void dowhile(void) {
        WHILE ws;

        ws.symbol_idx = local_table_index;
        ws.stack_pointer = stkp;
        ws.type = WSWHILE;
        ws.case_test = getlabel ();
        ws.while_exit = getlabel ();
        addwhile (&ws);
        generate_label (ws.case_test);
        test (ws.while_exit, FALSE);
        statement (NO);
        gen_jump (ws.case_test);
        generate_label (ws.while_exit);
        local_table_index = ws.symbol_idx;
        stkp = gen_modify_stack (ws.stack_pointer);
        delwhile ();
}
Ejemplo n.º 13
0
/*
 *	"while" statement
 */
void dowhile (void )
{
	INTPTR_T	ws[7];

	ws[WSSYM] = (INTPTR_T)locptr;
	ws[WSSP] = stkp;
	ws[WSTYP] = WSWHILE;
	ws[WSTEST] = getlabel ();
	ws[WSEXIT] = getlabel ();
	addwhile (ws);
	gnlabel (ws[WSTEST]);
	test (ws[WSEXIT], FALSE);
	statement (NO);
	jump (ws[WSTEST]);
	gnlabel (ws[WSEXIT]);
	locptr = (char*)ws[WSSYM];
	stkp = modstk (ws[WSSP]);
	delwhile ();
}
Ejemplo n.º 14
0
/*
 *	"for" statement
 */
void dofor (void )
{
    INTPTR_T ws[7];
    INTPTR_T *pws;

	ws[WSSYM] = (INTPTR_T)locptr;
	ws[WSSP] = stkp;
	ws[WSTYP] = WSFOR;
	ws[WSTEST] = getlabel ();
	ws[WSINCR] = getlabel ();
	ws[WSBODY] = getlabel ();
	ws[WSEXIT] = getlabel ();
	addwhile (ws);
	pws = readwhile ();
	needbrack ("(");
	if (!match (";")) {
		expression (YES);
		ns ();
	}
	gnlabel (pws[WSTEST]);
	if (!match (";")) {
		expression (YES);
		testjump (pws[WSBODY], TRUE);
		jump (pws[WSEXIT]);
		ns ();
	} else
		pws[WSTEST] = pws[WSBODY];
	gnlabel (pws[WSINCR]);
	if (!match (")")) {
		expression (YES);
		needbrack (")");
		jump (pws[WSTEST]);
	} else
		pws[WSINCR] = pws[WSTEST];
	gnlabel (pws[WSBODY]);
	statement (NO);
	jump (pws[WSINCR]);
	gnlabel (pws[WSEXIT]);
	locptr = (char *)pws[WSSYM];
	stkp = modstk (pws[WSSP]);
	delwhile ();
}
Ejemplo n.º 15
0
/**
 * "for" statement
 */
dofor() {
        loop_t loop;
        loop_t *p;

        loop.symbol_idx = local_table_index;
        loop.stack_pointer = stkp;
        loop.type = WSFOR;
        loop.test_label = getlabel ();
        loop.cont_label = getlabel ();
        loop.body_label = getlabel ();
        loop.exit_label = getlabel ();
        addloop (&loop);
        p = readloop ();
        needbrack ("(");
        if (!match (";")) {
                expression (YES);
                need_semicolon ();
        }
        generate_label (p->test_label);
        if (!match (";")) {
                expression (YES);
                gen_test_jump (p->body_label, TRUE);
                gen_jump (p->exit_label);
                need_semicolon ();
        } else
                p->test_label = p->body_label;
        generate_label (p->cont_label);
        if (!match (")")) {
                expression (YES);
                needbrack (")");
                gen_jump (p->test_label);
        } else
                p->cont_label = p->test_label;
        generate_label (p->body_label);
        statement (NO);
        gen_jump (p->cont_label);
        generate_label (p->exit_label);
        local_table_index = p->symbol_idx;
        stkp = gen_modify_stack (p->stack_pointer);
        delloop ();
}
Ejemplo n.º 16
0
/**
 * "for" statement
 */
void dofor(void) {
        WHILE ws;
        WHILE *pws;

        ws.symbol_idx = local_table_index;
        ws.stack_pointer = stkp;
        ws.type = WSFOR;
        ws.case_test = getlabel ();
        ws.incr_def = getlabel ();
        ws.body_tab = getlabel ();
        ws.while_exit = getlabel ();
        addwhile (&ws);
        pws = readwhile ();
        needbrack ("(");
        if (!match (";")) {
                expression (YES);
                need_semicolon ();
        }
        generate_label (pws->case_test);
        if (!match (";")) {
                expression (YES);
                gen_test_jump (pws->body_tab, TRUE);
                gen_jump (pws->while_exit);
                need_semicolon ();
        } else
                pws->case_test = pws->body_tab;
        generate_label (pws->incr_def);
        if (!match (")")) {
                expression (YES);
                needbrack (")");
                gen_jump (pws->case_test);
        } else
                pws->incr_def = pws->case_test;
        generate_label (pws->body_tab);
        statement (NO);
        gen_jump (pws->incr_def);
        generate_label (pws->while_exit);
        local_table_index = pws->symbol_idx;
        stkp = gen_modify_stack (pws->stack_pointer);
        delwhile ();
}
Ejemplo n.º 17
0
/**
 * "default" label
 */
dodefault() {
        loop_t *ptr;
        int        lab;

        if (ptr = readswitch ()) {
                ptr->cont_label = lab = getlabel ();
                generate_label (lab);
                if (!match (":"))
                        error ("missing colon");
        } else
                error ("no active switch");
}
Ejemplo n.º 18
0
/**
 * "default" label
 */
void dodefault(void) {
        WHILE *ptr;
        int        lab;

        if ((ptr = readswitch ()) != 0) {
                ptr->incr_def = lab = getlabel ();
                generate_label (lab);
                if (!match (":"))
                        error ("missing colon");
        } else
                error ("no active switch");
}
Ejemplo n.º 19
0
/**
 * "if" statement
 */
void doif(void) {
        int     fstkp, flab1, flab2;
        int     flev;

        flev = local_table_index;
        fstkp = stkp;
        flab1 = getlabel ();
        test (flab1, FALSE);
        statement (NO);
        stkp = gen_modify_stack (fstkp);
        local_table_index = flev;
        if (!amatch ("else", 4)) {
                generate_label (flab1);
                return;
        }
        gen_jump (flab2 = getlabel ());
        generate_label (flab1);
        statement (NO);
        stkp = gen_modify_stack (fstkp);
        local_table_index = flev;
        generate_label (flab2);
}
Ejemplo n.º 20
0
addcase (int val) {
    int     lab;

    if (swstp == SWSTSZ)
        error ("too many case labels");
    else {
        swstcase[swstp] = val;
        swstlab[swstp++] = lab = getlabel ();
        print_label (lab);
        output_label_terminator ();
        newline ();
    }
}
Ejemplo n.º 21
0
/*
 *	"if" statement
 */
void doif (void )
{
	int	fstkp, flab1, flab2;
	char	*flev;

	flev = locptr;
	fstkp = stkp;
	flab1 = getlabel ();
	test (flab1, FALSE);
	statement (NO);
	stkp = modstk (fstkp);
	locptr = flev;
	if (!amatch ("else", 4)) {
		gnlabel (flab1);
		return;
	}
	jump (flab2 = getlabel ());
	gnlabel (flab1);
	statement (NO);
	stkp = modstk (fstkp);
	locptr = flev;
	gnlabel (flab2);
}
Ejemplo n.º 22
0
/**
 * "do" statement
 */
void dodo(void) {
        WHILE ws;

        ws.symbol_idx = local_table_index;
        ws.stack_pointer = stkp;
        ws.type = WSDO;
        ws.body_tab = getlabel ();
        ws.case_test = getlabel ();
        ws.while_exit = getlabel ();
        addwhile (&ws);
        generate_label (ws.body_tab);
        statement (NO);
        if (!match ("while")) {
                error ("missing while");
                return;
        }
        generate_label (ws.case_test);
        test (ws.body_tab, TRUE);
        generate_label (ws.while_exit);
        local_table_index = ws.symbol_idx;
        stkp = gen_modify_stack (ws.stack_pointer);
        delwhile ();
}
Ejemplo n.º 23
0
/*
 *	"default" label
 */
void dodefault (void )
{
	INTPTR_T	*ptr,
		lab;

	ptr = readswitch ();
	if (ptr) {
		ptr[WSDEF] = lab = getlabel ();
		gnlabel (lab);
		if (!match (":"))
			error ("missing colon");
	} else
		error ("no active switch");
}
Ejemplo n.º 24
0
/**
 * "do" statement
 */
dodo() {
        loop_t loop;

        loop.symbol_idx = local_table_index;
        loop.stack_pointer = stkp;
        loop.type = WSDO;
        loop.body_label = getlabel ();
        loop.test_label = getlabel ();
        loop.exit_label = getlabel ();
        addloop (&loop);
        generate_label (loop.body_label);
        statement (NO);
        if (!match ("while")) {
                error ("missing while");
                return;
        }
        generate_label (loop.test_label);
        test (loop.body_label, TRUE);
        generate_label (loop.exit_label);
        local_table_index = loop.symbol_idx;
        stkp = gen_modify_stack (loop.stack_pointer);
        delloop ();
}
Ejemplo n.º 25
0
/*
 *	"do" statement
 */
void dodo (void )
{
	INTPTR_T ws[7];

	ws[WSSYM] = (INTPTR_T)locptr;
	ws[WSSP] = stkp;
	ws[WSTYP] = WSDO;
	ws[WSBODY] = getlabel ();
	ws[WSTEST] = getlabel ();
	ws[WSEXIT] = getlabel ();
	addwhile (ws);
	gnlabel (ws[WSBODY]);
	statement (NO);
	if (!match ("while")) {
		error ("missing while");
		return;
	}
	gnlabel (ws[WSTEST]);
	test (ws[WSBODY], TRUE);
	gnlabel (ws[WSEXIT]);
	locptr = (char*)ws[WSSYM];
	stkp = modstk (ws[WSSP]);
	delwhile ();
}
Ejemplo n.º 26
0
WORD getadr(const char *prog, const char *str, PASS pass)
{
    WORD adr = 0;

    if(str[0] == '=') {
        adr = getliteral(str, pass);
    } else if(isdigit(str[0]) || str[0] == '-' || str[0] == '#') {
        adr = nh2word(str);
    } else {
        if(pass == SECOND) {
            if((adr = getlabel(prog, str)) == 0xFFFF) {
                setcerr(103, str);    /* label not found */
            }
        }
    }
    return adr;
}
Ejemplo n.º 27
0
Archivo: oo_type.c Proyecto: 16Bitt/oo
void add_method(type_t type, char* name, type_t return_type, arg_list* args){
	type_container* tp = (type_container*) get(types, type);
	if(tp == NULL)
		error("No type to add method '%s' to", name);
	
	//Fill the container
	method_t* method = MKNEW(method_t);
	method->name		= name;
	method->return_type	= return_type;
	method->arguments	= args;
	method->label_start	= getlabel();
	
	//Add it to the type list
	append(tp->methods, method);
	
	//Throw down a label
	putlabel(method->label_start);
}
Ejemplo n.º 28
0
Archivo: goto.c Proyecto: z88dk/z88dk
int AddGoto(SYMBOL* ptr)
{
    GOTO_TAB* gptr;
    int gqptr = 0; /* Pointer int goto queue */

    debug(DBG_GOTO, "Adding goto label: %s\n", ptr->name);
    if (ptr->more)
        gqptr = ptr->more;
    if ((gptr = SearchGoto(ptr)))
        return (gptr->label);
    if (++gotocnt > NUMGOTO)
        errorfmt("Maximum number of gotos reached (%d)", 1, NUMGOTO);
    gptr = gotoq + gotocnt; /* Ref for our label */
    gptr->next = gqptr; /* store next in chain */
    ptr->more = gotocnt; /* Make us first */
    gptr->sp = Zsp; /* Store current stack */
    gptr->sym = ptr; /* What label do we reference */
    gptr->lineno = lineno;
    gptr->label = getlabel();
    return (gptr->label);
}
Ejemplo n.º 29
0
Archivo: c80.c Proyecto: adamsch1/scc
ask()
  {
  int k,num[1];
  kill();      /* clear input line */
  outbyte(12);    /* clear the screen */
  nl();nl();nl();    /* print banner */
  pl("   * * *  small-c compiler  * * *");
  nl();
  pl("            by Ron Cain");
  nl();nl();
  /* see if user wants to interleave the c-text */
  /*  in form of comments (for clarity) */
  pl("Do you want the c-text to appear? ");
  gets(line);    /* get answer */
  ctext=0;    /* assume no */
  if((ch()=='Y')|(ch()=='y'))
    ctext=1;  /* user said yes */
   /* see if user wants us to allocate static */
   /*  variables by name in this module  */
   /*  (pseudo external capability)  */
   pl("Do you wish the globals to be defined? ");
   gets(line);
   glbflag=0;
   if((ch()=='Y')|(ch()=='y'))
     glbflag=1;  /* user said yes */
  /* get first allowable number for compiler-generated */
   /*  labels (in case user will append modules) */
   while(1){
     pl("Starting number for labels? ");
     gets(line);
     if(ch()==0){num[0]=0;break;}
    if(k=number(num))break;
    }
  nxtlab=num[0];
  litlab=getlabel();  /* first label=literal pool */ 
  kill();      /* erase line */
  }
Ejemplo n.º 30
0
int dadsm_setup(
                CIFBLK          *cif,
                char            *pdsn[],
                DADSM           *dadsm, 
                int             verbose) {

        DSXTENT         *f1x;
        BYTE            *pcchhr;
        int             numx = MAX_EXTENTS;     // # extent slots available
        int             rc;


//  Read dasd volume label record

    rc = getlabel(cif, &dadsm->volrec, verbose);
    if (rc) return rc;

//  Read F4 DSCB, save VTOC extent info

    rc = getF4dscb(cif, &dadsm->f4buf, &dadsm->volrec, &dadsm->f4ext, verbose);
    if (rc) return rc;

//  Read F1 DSCB, save first three extents from F1 DSCB

    rc = getF1dscb(cif, pdsn, &dadsm->f1buf, (void *)&dadsm->f4ext, verbose);
    if (rc) return rc;

    f1x = &dadsm->f1ext[0];                     // @ extent # 0
    numx -= 3;                                  // will use 3 slots (if available)
    if (numx < 0) {
        fprintf(stderr, "dadsm_setup exhausted extent slots\n");
        return 1;
    }
    memcpy(f1x, &dadsm->f1buf.ds1ext1, sizeof(DSXTENT) * 3);
    f1x += 3;                                   // @ extent # 3
    dadsm->f1numx = dadsm->f1buf.ds1noepv;      // # extents alloc'd to dataset
    if (dadsm->f1numx < 4) {
        if (verbose > 1)
            fprintf(stderr, "dadsm_setup "
                "no F3 DSCB required, only %d extent(s); all in F1\n",
                dadsm->f1numx);
        return 0;
    }

//  When more than 3 extents, get additional extent info from F3 DSCB(s).
//  Chase the F3 chain starting with the CCHHR in the F1, accumulating
//  extent information for the dataset as we progress.

    pcchhr = (BYTE *)&dadsm->f1buf.ds1ptrds;            // @ F1 ptr to F3
    while (pcchhr[0] || pcchhr[1] || pcchhr[2] || pcchhr[3] || pcchhr[4]) {
        rc = getF3dscb(cif, pcchhr, &dadsm->f3buf, verbose);
        if (rc) return rc;
        numx -= 4;                              // use extent slots
        if (numx < 0) {
            fprintf(stderr, "dadsm_setup exhausted extent slots\n");
            return 2;
        }
        memcpy(f1x, &dadsm->f3buf.ds3extnt[0], sizeof(DSXTENT) * 4);
        f1x += 4;
        numx -= 9;                              // use extent slots
        if (numx < 0) {
            fprintf(stderr, "dadsm_setup exhausted extent slots\n");
            fprintf(stderr, "Maximum supported extents %d\n", MAX_EXTENTS);
            return 3;
        }
        memcpy(f1x, &dadsm->f3buf.ds3adext[0], sizeof(DSXTENT) * 9);
        f1x += 9;
        pcchhr = (BYTE *)&dadsm->f3buf.ds3ptrds;        // @ next F3 CCHHR
    }
    return 0;
} /* dadsm_setup */