axiom-source 20170501-3 / usr / share / axiom-20170501 / src / algebra / OMDEV.spad

)abbrev domain OMDEV OpenMathDevice
++ Author: Vilya Harvey
++ Description: 
++ \spadtype{OpenMathDevice} provides support for reading
++ and writing openMath objects to files, strings etc.  It also provides
++ access to low-level operations from within the interpreter.

OpenMathDevice() : SIG == CODE where

  SIG ==> with

    OMopenFile : (String, String, OpenMathEncoding) -> %
      ++ OMopenFile(f,mode,enc) opens file \axiom{f} for reading or writing
      ++ OpenMath objects (depending on \axiom{mode} which can be "r", "w"
      ++ or "a" for read, write and append respectively), in the encoding
      ++ \axiom{enc}.

    OMopenString : (String, OpenMathEncoding) -> %
      ++ OMopenString(s,mode) opens the string \axiom{s} for reading or 
      ++ writing OpenMath objects in encoding \axiom{enc}.

    OMclose : % -> Void
      ++ OMclose(dev) closes \axiom{dev}, flushing output if necessary.

    OMsetEncoding : (%, OpenMathEncoding) -> Void
      ++ OMsetEncoding(dev,enc) sets the encoding used for reading or writing
      ++ OpenMath objects to or from \axiom{dev} to \axiom{enc}.

    OMputApp : % -> Void
      ++ OMputApp(dev) writes a begin application token to \axiom{dev}.

    OMputAtp : % -> Void
      ++ OMputAtp(dev) writes a begin attribute pair token to \axiom{dev}.

    OMputAttr : % -> Void
      ++ OMputAttr(dev) writes a begin attribute token to \axiom{dev}.

    OMputBind : % -> Void
      ++ OMputBind(dev) writes a begin binder token to \axiom{dev}.

    OMputBVar : % -> Void
      ++ OMputBVar(dev) writes a begin bound variable list token to \axiom{dev}

    OMputError : % -> Void
      ++ OMputError(dev) writes a begin error token to \axiom{dev}.

    OMputObject : % -> Void
      ++ OMputObject(dev) writes a begin object token to \axiom{dev}.

    OMputEndApp : % -> Void
      ++ OMputEndApp(dev) writes an end application token to \axiom{dev}.

    OMputEndAtp : % -> Void
      ++ OMputEndAtp(dev) writes an end attribute pair token to \axiom{dev}.

    OMputEndAttr : % -> Void
      ++ OMputEndAttr(dev) writes an end attribute token to \axiom{dev}.

    OMputEndBind : % -> Void
      ++ OMputEndBind(dev) writes an end binder token to \axiom{dev}.

    OMputEndBVar : % -> Void
      ++ OMputEndBVar(dev) writes an end bound variable list token to 
      ++ \axiom{dev}.

    OMputEndError : % -> Void
      ++ OMputEndError(dev) writes an end error token to \axiom{dev}.

    OMputEndObject : % -> Void
      ++ OMputEndObject(dev) writes an end object token to \axiom{dev}.

    OMputInteger : (%, Integer) -> Void
      ++ OMputInteger(dev,i) writes the integer \axiom{i} to \axiom{dev}.

    OMputFloat : (%, DoubleFloat) -> Void
      ++ OMputFloat(dev,i) writes the float \axiom{i} to \axiom{dev}.

    OMputVariable : (%, Symbol) -> Void
      ++ OMputVariable(dev,i) writes the variable \axiom{i} to \axiom{dev}.

    OMputString : (%, String) -> Void
      ++ OMputString(dev,i) writes the string \axiom{i} to \axiom{dev}.

    OMputSymbol : (%, String, String) -> Void
      ++ OMputSymbol(dev,cd,s) writes the symbol \axiom{s} from CD \axiom{cd}
      ++ to \axiom{dev}.

    OMgetApp : % -> Void
      ++ OMgetApp(dev) reads a begin application token from \axiom{dev}.

    OMgetAtp : % -> Void
      ++ OMgetAtp(dev) reads a begin attribute pair token from \axiom{dev}.

    OMgetAttr : % -> Void
      ++ OMgetAttr(dev) reads a begin attribute token from \axiom{dev}.

    OMgetBind : % -> Void
      ++ OMgetBind(dev) reads a begin binder token from \axiom{dev}.

    OMgetBVar : % -> Void
      ++ OMgetBVar(dev) reads a begin bound variable list token from 
      ++ \axiom{dev}.

    OMgetError : % -> Void
      ++ OMgetError(dev) reads a begin error token from \axiom{dev}.

    OMgetObject : % -> Void
      ++ OMgetObject(dev) reads a begin object token from \axiom{dev}.

    OMgetEndApp : % -> Void
      ++ OMgetEndApp(dev) reads an end application token from \axiom{dev}.

    OMgetEndAtp : % -> Void
      ++ OMgetEndAtp(dev) reads an end attribute pair token from \axiom{dev}.

    OMgetEndAttr : % -> Void
      ++ OMgetEndAttr(dev) reads an end attribute token from \axiom{dev}.

    OMgetEndBind : % -> Void
      ++ OMgetEndBind(dev) reads an end binder token from \axiom{dev}.

    OMgetEndBVar : % -> Void
      ++ OMgetEndBVar(dev) reads an end bound variable list token from 
      ++ \axiom{dev}.

    OMgetEndError : % -> Void
      ++ OMgetEndError(dev) reads an end error token from \axiom{dev}.

    OMgetEndObject : % -> Void
      ++ OMgetEndObject(dev) reads an end object token from \axiom{dev}.

    OMgetInteger : % -> Integer
      ++ OMgetInteger(dev) reads an integer from \axiom{dev}.

    OMgetFloat : % -> DoubleFloat
      ++ OMgetFloat(dev) reads a float from \axiom{dev}.

    OMgetVariable : % -> Symbol
      ++ OMgetVariable(dev) reads a variable from \axiom{dev}.

    OMgetString : % -> String
      ++ OMgetString(dev) reads a string from \axiom{dev}.

    OMgetSymbol : % -> Record(cd:String, name:String)
      ++ OMgetSymbol(dev) reads a symbol from \axiom{dev}.

    OMgetType : % -> Symbol
      ++ OMgetType(dev) returns the type of the next object on \axiom{dev}.

  CODE ==> add

    OMopenFile(fname: String, fmode: String, enc: OpenMathEncoding): % ==
      OM_-OPENFILEDEV(fname, fmode, enc)$Lisp

    OMopenString(str: String, enc: OpenMathEncoding): % ==
      OM_-OPENSTRINGDEV(str, enc)$Lisp

    OMclose(dev: %): Void ==
      OM_-CLOSEDEV(dev)$Lisp

    OMsetEncoding(dev: %, enc: OpenMathEncoding): Void ==
      OM_-SETDEVENCODING(dev, enc)$Lisp

    OMputApp(dev: %): Void == OM_-PUTAPP(dev)$Lisp

    OMputAtp(dev: %): Void == OM_-PUTATP(dev)$Lisp

    OMputAttr(dev: %): Void == OM_-PUTATTR(dev)$Lisp

    OMputBind(dev: %): Void == OM_-PUTBIND(dev)$Lisp

    OMputBVar(dev: %): Void == OM_-PUTBVAR(dev)$Lisp

    OMputError(dev: %): Void == OM_-PUTERROR(dev)$Lisp

    OMputObject(dev: %): Void == OM_-PUTOBJECT(dev)$Lisp

    OMputEndApp(dev: %): Void == OM_-PUTENDAPP(dev)$Lisp

    OMputEndAtp(dev: %): Void == OM_-PUTENDATP(dev)$Lisp

    OMputEndAttr(dev: %): Void == OM_-PUTENDATTR(dev)$Lisp

    OMputEndBind(dev: %): Void == OM_-PUTENDBIND(dev)$Lisp

    OMputEndBVar(dev: %): Void == OM_-PUTENDBVAR(dev)$Lisp

    OMputEndError(dev: %): Void == OM_-PUTENDERROR(dev)$Lisp

    OMputEndObject(dev: %): Void == OM_-PUTENDOBJECT(dev)$Lisp

    OMputInteger(dev: %, i: Integer): Void == OM_-PUTINT(dev, i)$Lisp

    OMputFloat(dev: %, f: DoubleFloat): Void == OM_-PUTFLOAT(dev, f)$Lisp

    OMputVariable(dev: %, v: Symbol): Void == OM_-PUTVAR(dev, v)$Lisp

    OMputString(dev: %, s: String): Void == OM_-PUTSTRING(dev, s)$Lisp

    OMputSymbol(dev: %, cd: String, nm: String): Void ==
      OM_-PUTSYMBOL(dev, cd, nm)$Lisp

    OMgetApp(dev: %): Void == OM_-GETAPP(dev)$Lisp

    OMgetAtp(dev: %): Void == OM_-GETATP(dev)$Lisp

    OMgetAttr(dev: %): Void == OM_-GETATTR(dev)$Lisp

    OMgetBind(dev: %): Void == OM_-GETBIND(dev)$Lisp

    OMgetBVar(dev: %): Void == OM_-GETBVAR(dev)$Lisp

    OMgetError(dev: %): Void == OM_-GETERROR(dev)$Lisp

    OMgetObject(dev: %): Void == OM_-GETOBJECT(dev)$Lisp

    OMgetEndApp(dev: %): Void == OM_-GETENDAPP(dev)$Lisp

    OMgetEndAtp(dev: %): Void == OM_-GETENDATP(dev)$Lisp

    OMgetEndAttr(dev: %): Void == OM_-GETENDATTR(dev)$Lisp

    OMgetEndBind(dev: %): Void == OM_-GETENDBIND(dev)$Lisp

    OMgetEndBVar(dev: %): Void == OM_-GETENDBVAR(dev)$Lisp

    OMgetEndError(dev: %): Void == OM_-GETENDERROR(dev)$Lisp

    OMgetEndObject(dev: %): Void == OM_-GETENDOBJECT(dev)$Lisp

    OMgetInteger(dev: %): Integer == OM_-GETINT(dev)$Lisp

    OMgetFloat(dev: %): DoubleFloat == OM_-GETFLOAT(dev)$Lisp

    OMgetVariable(dev: %): Symbol == OM_-GETVAR(dev)$Lisp

    OMgetString(dev: %): String == OM_-GETSTRING(dev)$Lisp

    OMgetSymbol(dev: %): Record(cd:String, name:String) ==
      OM_-GETSYMBOL(dev)$Lisp

    OMgetType(dev: %): Symbol == OM_-GETTYPE(dev)$Lisp