
<<RoseTranslateInsides.Mesa>>
<<Last Edited by: Spreitzer, September 28, 1984 8:18:28 pm PDT PDT PDT>>

    DIRECTORY IO, OpPrecParse, RoseTranslateTypes, BasicTime, TiogaFileOps, Commander;

    RoseTranslateInsides: CEDAR DEFINITIONS =

    BEGIN OPEN RoseTranslateTypes;

    <<Familiar Types:>>

        TokenClassList: TYPE = LIST OF TokenClass;
        TokenClass: TYPE = OpPrecParse.TokenClass;
        TokenClassRep: TYPE = OpPrecParse.TokenClassRep;


    <<Errors:>>

        Circularity: ERROR;


    <<Top Level Things:>>

        Job: TYPE = REF JobRep;
        JobRep: TYPE = RECORD [
            exec: Commander.Handle,
            rootName: ROPE,
            path: LIST OF ROPE _ NIL,
            outRoot, symbolsRoot: TiogaFileOps.Ref,
            from, log: IO.STREAM _ NIL,
            errCount, warnCount, tokenCount: CARDINAL _ 0,
            to, symbolsStream, typeStream, directoryStream, importsStream, openStream, regStream: IO.STREAM,    --actually TiogaStreams
            parseTree: REF ANY _ NIL,
            directory, imports, opened, libbed: SymbolTable _ NIL,
            previewing: BOOL _ FALSE,
            nodeCreateHacks: SymbolTable _ NIL,
            nchCount, symGen: CARDINAL _ 0,
            things: SymbolTable _ NIL,
            used: SymbolTable _ NIL,
            type: JobType _ TranslateJob,
            emptyDirectory, emptyImports, emptyOpen: BOOLEAN _ TRUE,
            start: BasicTime.Pulses _ 0];

        JobType: TYPE = {TranslateJob, Other};

        viewerLog: IO.STREAM;
        omitted: REF ANY;

        Op: TYPE = REF OpRep;
        OpRep: TYPE = RECORD [
            name: ROPE,
            class: ARRAY BOOLEAN OF OpPrecParse.TokenClass,
            eatsCedar: BOOLEAN _ FALSE];

        WasRef: TYPE = REF WasRefRep; WasRefRep: TYPE = RECORD [r: ROPE];

        wasRef: WasRef;


    <<Procedures:>>

        Translate: PROC [exec: Commander.Handle, rootName: ROPE, pathIn: LIST OF ROPE, type: JobType] RETURNS [errCount: CARDINAL];

        ParseExpression: PROC [job: Job] RETURNS [expr: REF ANY];

        dashClass, assertClass, arrowClass, colonClass, ltClass, gtClass, eqClass, commaClass, lambdaClass, returnClass, squareClass, 
        applClass, rsClass, semiClass, cellClass, cellEndClass, nameClass, portsProcClass, applyClass, stateClass, initStateClass, 
        ioCreatorClass, ioRefTypeClass, initializerClass, expandClass, portsClass, cedarClass, bbTestClass, stTestClass, 
        initCTPropsClass, errorClass, directoryClass, importsClass, openClass, libClass, noisyErrClass, myArgClass: TokenClass;

        ReduceNoisily, SimplerReduce, ReduceError, ReduceSquare, ReduceBinding, ReduceArrow, ReduceDash, ReduceAssert, ReduceComma, 
        ReduceSemi, ReduceDirectory, ReduceImports, ReduceOpen, ReduceLibrary, ReduceIntElt, ReduceLambda, ReduceAppl, ReduceName, 
        ReduceCell, ReducePortsProc, ReduceApply, ReduceState, ReduceInitState, ReducePorts, ReduceExpand, ReduceIOCreator, 
        ReduceIORefType, ReduceInitializer, ReduceEval, ReduceBBTest, ReduceSTTest, ReduceInitCTProps: OpPrecParse.Reducer;

        ErrCheck: PROC [args: OpPrecParse.ArgList] RETURNS [errFound: BOOLEAN];
        OpsCheck: PROC [context: REF ANY, sr: SourceRange, ops: OpPrecParse.TokenList, classes: TokenClassList] RETURNS [err: BOOL];
        Sofar: PROC [sr: SourceRange, context, org: REF ANY] RETURNS [cd: CellDef];
        InsistOnCedarSource: PROC [context: REF ANY, sofar: REF ANY, args: OpPrecParse.ArgList] RETURNS [cs: CedarSource, reduced: REF ANY];

        AddDirectory, AddImport, AddOpen: PROC [job: Job, name: ROPE];

        AddMesa: PROC [job: Job, m: Mesa];

        AddSymbols: PROC [job: Job, rootName: ROPE];

        AddCellClass: PROC [job: Job, cce: ccEntry];

        AddCellFn: PROC [job: Job, cfe: cfEntry];

        ForceMesaType: PROC [mesaType: ROPE, on: NodeType] RETURNS [forced: NodeType];

        DigestInterface: PROC [context: REF ANY, iel: InterfaceEltList] RETURNS [di: DigestedInterface];

        InstantiateSignalType: PROC [context: REF ANY, name: ROPE, parms: REF ANY] RETURNS [sti: SignalTypeInvocation];

        TypeCheck: PROC [job: Job, defName: ROPE, args: REF ANY, interface: DigestedInterface, instanceName: ROPE];

        Complain: PROC [sr: SourceRange, context: REF ANY, complaint: ROPE, v1, v2, v3, v4, v5: IO.Value _ [null[]]] RETURNS [reduced: REF 
        ANY];

        Whimper: PROC [sr: SourceRange, context: REF ANY, complaint: ROPE, v1, v2, v3, v4, v5: IO.Value _ [null[]]];

        MyBreak: IO.BreakProc;

        Close: PROC [job: Job];

        etNames: ARRAY EvalType OF ROPE;

        TranslatePiece: PROC [job: Job, asAny: REF ANY];
        WriteRegistration: PROC [to: IO.STREAM, result, name: ROPE, cellDef: CellDef];
        WriteInterfaceDecls: PROC [job: Job, name, ioRefTypeName: ROPE, di: DigestedInterface, function: BOOL] RETURNS [iCount: CARDINAL];
        WriteInitializer: PROC [job: Job, name: ROPE, cs: CedarSource, cellDef: CellDef];
        WriteInvocation: PROC [to: IO.STREAM, i: Invocation];
        WriteExpand: PROC [job: Job, name: ROPE, ec: LORA, cellDef: CellDef];
        WriteEval: PROC [job: Job, name: ROPE, et: EvalType, cs: CedarSource, cellDef: CellDef];

        WriteBindingList: PROC [to: IO.STREAM, bl: BindingList];
        WriteCellFnInvocation: PROC [to: IO.STREAM, i: Invocation];
        WriteArgs: PROC [to: IO.STREAM, args: Args];

        InjectCedar: PROC [job: Job, cs: CedarSource];


    END.