builtin.p

<B>Digital的Unix操作系统VAX 4.2源码</B>

(*#@(#)builtin.p	4.1	Ultrix	7/17/90 *)
(****************************************************************************
 *									    *
 *  Copyright (c) 1984 by						    *
 *  DIGITAL EQUIPMENT CORPORATION, Maynard, Massachusetts.		    *
 *  All rights reserved.						    *
 * 									    *
 *  This software is furnished under a license and may be used and copied   *
 *  only in  accordance with  the  terms  of  such  license  and with the   *
 *  inclusion of the above copyright notice. This software or  any  other   *
 *  copies thereof may not be provided or otherwise made available to any   *
 *  other person.  No title to and ownership of  the  software is  hereby   *
 *  transferred.							    *
 * 									    *
 *  The information in this software is  subject to change without notice   *
 *  and  should  not  be  construed as  a commitment by DIGITAL EQUIPMENT   *
 *  CORPORATION.							    *
 * 									    *
 *  DIGITAL assumes no responsibility for the use  or  reliability of its   *
 *  software on equipment which is not supplied by DIGITAL.		    *
 * 									    *
$Header: builtin.p,v 1.6 84/06/06 12:51:01 powell Exp $
 ****************************************************************************)
#include "globals.h"
#include "const.h"
#include "decls.h"
#include "bexpr.h"
#include "cexpr.h"
#include "builtin.h"
#include "optim.h"
#include "otree.h"
#include "ocount.h"

var
    allocateString, deallocateString : String;

procedure InitUnixProcNames;
begin
    unixProcNames[1] := 'exit';
    unixProcNames[2] := 'fork';
    unixProcNames[3] := 'read';
    unixProcNames[4] := 'write';
    unixProcNames[5] := 'open';
    unixProcNames[6] := 'close';
    unixProcNames[7] := 'wait';
    unixProcNames[8] := 'creat';
    unixProcNames[9] := 'link';
    unixProcNames[10] := 'unlink';
    unixProcNames[11] := 'exec';
    unixProcNames[12] := 'chdir';
    unixProcNames[13] := 'time';
    unixProcNames[14] := 'mknod';
    unixProcNames[15] := 'chmod';
    unixProcNames[16] := 'chown';
    unixProcNames[17] := 'break';
    unixProcNames[18] := 'stat';
    unixProcNames[19] := 'lseek';
    unixProcNames[20] := 'getpid';
    unixProcNames[21] := 'mount';
    unixProcNames[22] := 'umount';
    unixProcNames[23] := 'setuid';
    unixProcNames[24] := 'getuid';
    unixProcNames[25] := 'stime';
    unixProcNames[26] := 'ptrace';
    unixProcNames[27] := 'alarm';
    unixProcNames[28] := 'fstat';
    unixProcNames[29] := 'pause';
    unixProcNames[30] := 'utime';
    unixProcNames[31] := 'stty';
    unixProcNames[32] := 'gtty';
    unixProcNames[33] := 'access';
    unixProcNames[34] := 'nice';
    unixProcNames[35] := 'ftime';
    unixProcNames[36] := 'sync';
    unixProcNames[37] := 'kill';
    unixProcNames[38] := 'switch';
    unixProcNames[39] := 'setpgrp';
    unixProcNames[40] := 'tell';
    unixProcNames[41] := 'dup';
    unixProcNames[42] := 'pipe';
    unixProcNames[43] := 'times';
    unixProcNames[44] := 'profil';
    unixProcNames[45] := '???';
    unixProcNames[46] := 'setgid';
    unixProcNames[47] := 'getgid';
    unixProcNames[48] := 'signal';
    unixProcNames[49] := '???';
    unixProcNames[50] := '???';
    unixProcNames[51] := 'acct';
    unixProcNames[52] := 'setphys';
    unixProcNames[53] := 'syslock';
    unixProcNames[54] := 'ioctl';
    unixProcNames[55] := 'reboot';
    unixProcNames[56] := 'mpx';
    unixProcNames[57] := '???';
    unixProcNames[58] := '???';
    unixProcNames[59] := 'exece';
    unixProcNames[60] := 'umask';
    unixProcNames[61] := 'chroot';
    unixProcNames[62] := '???';
    unixProcNames[63] := '???';
    unixProcNames[64] := '???';
    unixProcNames[65] := '???';
    unixProcNames[66] := 'vfork';
    unixProcNames[67] := 'vread';
    unixProcNames[68] := 'vwrite';
    unixProcNames[69] := 'smdate';
    unixProcNames[70] := 'brk';
    unixProcNames[71] := 'sbrk';
end;

procedure InitBuiltin;
var
    name : String;
    sym : Symbol;
    mn : ModuleNode;
    pn : ProcNode;
    paramList : ParamList;
    exports : IdentList;
    cn : ConstNode;
    vn : VarNode;
    error : boolean;
    saveScope : Scope;
begin
    error := false;
    { Enter system types }
    { DEFINITION MODULE SYSTEM }
    AddText('SYSTEM');
    name := NewString;
    mn := DefineModule(name,TKBEGIN);
    exports := AddToIdentList(nil,nil);

    AddText('WORD');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    DefineType(name,wordTypeNode);

    AddText('BYTE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    DefineType(name,byteTypeNode);

    AddText('ADDRESS');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    DefineType(name,addressTypeNode);

    AddText('ADR');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPADR;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('SIZE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPSIZE;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('TSIZE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPTSIZE;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BYTESIZE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBYTESIZE;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('TBYTESIZE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPTBYTESIZE;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('CPUTIME');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPCPUTIME;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('UNIXCALL');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPUNIXCALL;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BYTESPERWORD');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := WORDSIZE div BYTESIZE;
    DefineConst(name,cn);

    AddText('BITSPERWORD');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := WORDSIZE;
    DefineConst(name,cn);

    AddText('BITSPERBYTE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := BYTESIZE;
    DefineConst(name,cn);

    AddText('MOSTSIGBIT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := WORDSIZE-1;
    DefineConst(name,cn);

    AddText('LEASTSIGBIT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := 0;
    DefineConst(name,cn);

    AddText('MAXUNSIGNED');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := MAXCARD;
    DefineConst(name,cn);

    AddText('MAXCARD');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    if standardCardinalFlag then begin
	cn^.cardVal := MAXCARD;
    end else begin
	cn^.cardVal := MAXINT;
    end;
    DefineConst(name,cn);

    AddText('MAXINT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    new(cn);
    cn^.kind := DTCARDINAL;
    cn^.cardVal := MAXINT;
    DefineConst(name,cn);

    AddText('PROCESS');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    DefineType(name,processTypeNode);

    AddText('NEWPROCESS');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPNEWPROCESS;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('TRANSFER');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPTRANSFER;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    Export(exports,TKQUALIFIED);

    EndModule(mn,nil,nil);

    AddText('BITOPERATIONS');
    name := NewString;
    mn := DefineModule(name,TKBEGIN);
    exports := AddToIdentList(nil,nil);

    AddText('BITAND');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITAND;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITOR');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITOR;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITNOT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITNOT;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITXOR');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITXOR;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITSHIFTLEFT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITSHIFTLEFT;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITSHIFTRIGHT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITSHIFTRIGHT;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITINSERT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITINSERT;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('BITEXTRACT');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPBITEXTRACT;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    Export(exports,TKQUALIFIED);

    EndModule(mn,nil,nil);

    { get strings for allocate and deallocate }
    { as you define memory module }

    AddText('MEMORY');
    name := NewString;
    mn := DefineModule(name,TKBEGIN);
    exports := AddToIdentList(nil,nil);

    AddText('ALLOCATE');
    name := NewString;
    allocateString := name;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPALLOCATE;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('DEALLOCATE');
    name := NewString;
    deallocateString := name;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPDEALLOCATE;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    Export(exports,TKQUALIFIED);

    EndModule(mn,nil,nil);


    { DEFINITION MODULE IO }
    AddText('IO');
    name := NewString;
    mn := DefineModule(name,TKBEGIN);

    exports := AddToIdentList(nil,nil);

    AddText('FILE');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    DefineType(name,fileTypeNode);

    AddText('WRITEF');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPWRITEF;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('READF');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPREADF;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('SWRITEF');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPWRITES;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('SREADF');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPREADS;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('WRITEB');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPWRITEB;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('READB');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPREADB;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('WRITEC');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));
    pn := DefineProc(name,TKPROCEDURE);
    pn^.builtin := BIPWRITEC;
    pn^.procType := builtinProcTypeNode;
    EndProc(pn,nil,nil);

    AddText('READC');
    name := NewString;
    exports := AddToIdentList(exports,MakeIdent(name));