Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| GNU Prolog for Java
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## gnu.prolog.vm
Class Environment

    java.lang.Object
      gnu.prolog.vm.Environment

All Implemented Interfaces:
  PredicateListener, EventListener

    public class Environment

extends Object
implements PredicateListener

this class represent prolog processor.

Nested Class Summary
`static class` | `Environment.DoubleQuotesValue` The possible values of the `double_quotes flag`

Field Summary
`protected Map<AtomTerm,PrologStream>` | `alias2stream`
`protected Map<AtomTerm,Term>` | `atom2flag` atom to flag
`static AtomTerm` | `boundedAtom`
`protected Set<AtomTerm>` | `changableFlags`
`static AtomTerm` | `charConversionAtom`
`protected PrologStream` | `currentInput`
`protected PrologStream` | `currentOutput`
`static AtomTerm` | `debugAtom`
`static AtomTerm` | `dialectAtom`
`static AtomTerm` | `dialectTerm`
`static AtomTerm` | `doubleQuotesAtom`
`static AtomTerm` | `downAtom`
`static AtomTerm` | `errorAtom`
`static AtomTerm` | `flagValueAtom`
`static AtomTerm` | `integerRoundingFunctionAtom`
`static IntegerTerm` | `maxIntegerTerm`
`static IntegerTerm` | `minIntegerTerm`
`static AtomTerm` | `modifyAtom`
`static AtomTerm` | `offAtom`
`static AtomTerm` | `onAtom`
`protected List<PrologStream>` | `openStreams`
`protected OperatorSet` | `opSet`
`static CompoundTermTag` | `plusTag`
`protected ReferenceQueue<? super PrologCodeListener>` | `prologCodeListenerReferenceQueue`
`static AtomTerm` | `prologFlagAtom`
`protected PrologTextLoaderState` | `prologTextLoaderState` current state of loaded database
`protected Map<CompoundTermTag,PrologCode>` | `tag2code` PredicateTag to code mapping
`protected Map<CompoundTermTag,List<gnu.prolog.vm.Environment.PrologCodeListenerRef>>` | `tag2listeners`
`static AtomTerm` | `towardZeroAtom`
`protected PrologCode` | `undefinedPredicate` predicate which used instead of real code when predicate is not defined
`static AtomTerm` | `unknownAtom`
`protected PrologStream` | `userInput`
`protected PrologStream` | `userOutput`
`static AtomTerm` | `versionAtom`
`static IntegerTerm` | `versionTerm`
`static AtomTerm` | `warningAtom`

Constructor Summary
`Environment()` constructor of environment, it loads buildins to database at start.
`Environment(InputStream stdin, OutputStream stdout)`

Method Summary
`void` | `addPrologCodeListener(CompoundTermTag tag, PrologCodeListener listener)` add prolog code listener
`boolean` | `close(PrologStream stream)`
`void` | `closeStreams()` Closes all open streams
`Interpreter` | `createInterpreter()` create interpreter for this environment Use this to create different `Interpreters` for different threads.
`protected void` | `createNewPrologFlag(AtomTerm flag, Term newValue, boolean changable)` create a new flag for this environment
`protected void` | `createTextLoader()`
`void` | `ensureLoaded(Term term)` Ensure that prolog text designated by term is loaded You must use `runInitialization(Interpreter)` after using this and before expecting answers.
`CharConversionTable` | `getConversionTable()`
`PrologStream` | `getCurrentInput()`
`PrologStream` | `getCurrentOutput()`
`static InputStream` | `getDefaultInputStream()`
`static OutputStream` | `getDefaultOutputStream()`
`List<PrologTextLoaderError>` | `getLoadingErrors()`
`Module` | `getModule()`
`OperatorSet` | `getOperatorSet()`
`PrologCode` | `getPrologCode(CompoundTermTag tag)` get prolog code
`Term` | `getPrologFlag(AtomTerm term)` get flag for this environment
`Map<AtomTerm,Term>` | `getPrologFlags()` get copy of current state of flags for this environment
`PrologTextLoaderState` | `getPrologTextLoaderState()`
`Map<PrologStream,List<Term>>` | `getStreamProperties()`
`PrologTextLoaderState` | `getTextLoaderState()` Deprecated.
`PrologCode` | `getUndefinedPredicateCode(CompoundTermTag tag)` get undefined predicate code
`PrologStream` | `getUserInput()`
`PrologStream` | `getUserOutput()`
`protected void` | `initEnvironment()` Initialize the environment
`protected void` | `initStreams(InputStream stdin, OutputStream stdout)`
`boolean` | `isInitialized()` true if the environment is currently initialized
`PrologCode` | `loadPrologCode(CompoundTermTag tag)` load code for prolog
`Term` | `open(AtomTerm source_sink, AtomTerm mode, PrologStream.OpenOptions options)`
`protected void` | `pollPrologCodeListeners()`
`void` | `predicateUpdated(PredicateUpdatedEvent evt)`
`void` | `removePrologCodeListener(CompoundTermTag tag, PrologCodeListener listener)` remove prolog code listener
`PrologStream` | `resolveStream(Term stream_or_alias)`
`void` | `runInitialization(Interpreter interpreter)` Run the initialization.
`void` | `setCurrentInput(PrologStream stream)`
`void` | `setCurrentOutput(PrologStream stream)`
`static void` | `setDefaultInputStream(InputStream defaultInputStream)`
`static void` | `setDefaultOutputStream(OutputStream defaultOutputStream)`
`void` | `setPrologFlag(AtomTerm flag, Term newValue)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### opSet

    protected OperatorSet opSet

### prologTextLoaderState

    protected PrologTextLoaderState prologTextLoaderState

  current state of loaded database

### undefinedPredicate

    protected PrologCode undefinedPredicate

  predicate which used instead of real code when predicate is not defined

### tag2code

    protected Map<CompoundTermTag,PrologCode> tag2code

  PredicateTag to code mapping

### boundedAtom

    public static final AtomTerm boundedAtom

### integerRoundingFunctionAtom

    public static final AtomTerm integerRoundingFunctionAtom

### downAtom

    public static final AtomTerm downAtom

### towardZeroAtom

    public static final AtomTerm towardZeroAtom

### charConversionAtom

    public static final AtomTerm charConversionAtom

### onAtom

    public static final AtomTerm onAtom

### offAtom

    public static final AtomTerm offAtom

### debugAtom

    public static final AtomTerm debugAtom

### unknownAtom

    public static final AtomTerm unknownAtom

### errorAtom

    public static final AtomTerm errorAtom

### warningAtom

    public static final AtomTerm warningAtom

### doubleQuotesAtom

    public static final AtomTerm doubleQuotesAtom

### dialectAtom

    public static final AtomTerm dialectAtom

### versionAtom

    public static final AtomTerm versionAtom

### maxIntegerTerm

    public static final IntegerTerm maxIntegerTerm

### minIntegerTerm

    public static final IntegerTerm minIntegerTerm

### dialectTerm

    public static final AtomTerm dialectTerm

### versionTerm

    public static final IntegerTerm versionTerm

### prologFlagAtom

    public static final AtomTerm prologFlagAtom

### flagValueAtom

    public static final AtomTerm flagValueAtom

### modifyAtom

    public static final AtomTerm modifyAtom

### plusTag

    public static final CompoundTermTag plusTag

### atom2flag

    protected Map<AtomTerm,Term> atom2flag

  atom to flag

### changableFlags

    protected Set<AtomTerm> changableFlags

### tag2listeners

    protected Map<CompoundTermTag,List<gnu.prolog.vm.Environment.PrologCodeListenerRef>> tag2listeners

### prologCodeListenerReferenceQueue

    protected ReferenceQueue<? super PrologCodeListener> prologCodeListenerReferenceQueue

### userInput

    protected PrologStream userInput

### userOutput

    protected PrologStream userOutput

### currentInput

    protected PrologStream currentInput

### currentOutput

    protected PrologStream currentOutput

### openStreams

    protected List<PrologStream> openStreams

### alias2stream

    protected Map<AtomTerm,PrologStream> alias2stream

Constructor Detail

### Environment

    public Environment()

  constructor of environment, it loads buildins to database at start.

### Environment

    public Environment(InputStream stdin,
                       OutputStream stdout)

Method Detail

### initEnvironment

    protected void initEnvironment()

  Initialize the environment

### createTextLoader

    protected void createTextLoader()

### getTextLoaderState

    @Deprecated
    public PrologTextLoaderState getTextLoaderState()

  Deprecated.

### isInitialized

    public boolean isInitialized()

  true if the environment is currently initialized

  Returns:
    if the environment is currently initialized

### runInitialization

    public void runInitialization(Interpreter interpreter)

  Run the initialization. This executes any goals loaded into the initailization list by the :-initialization(Goal). directive or by the use of the NONISO abbreviation :- Goal. This should be run after `ensureLoaded(Term)` with the `Interpreter` obtained from `createInterpreter()`.

  Parameters:
    `interpreter` -

### getPrologFlags

    public Map<AtomTerm,Term> getPrologFlags()

  get copy of current state of flags for this environment

  Returns:
    copy of current state of flags for this environment

### getPrologFlag

    public Term getPrologFlag(AtomTerm term)

  get flag for this environment

  Parameters:
    `term` - the flag to get the value of
  Returns:
    the value of the flag

### createNewPrologFlag

    protected void createNewPrologFlag(AtomTerm flag,
                                       Term newValue,
                                       boolean changable)

  create a new flag for this environment

  Parameters:
    `flag` - the flag to add
    `newValue` - the value of the flag
    `changable` - whether the flag's value can be changed

### setPrologFlag

    public void setPrologFlag(AtomTerm flag,
                              Term newValue)
                       throws PrologException

  Throws:
    `PrologException`

### getLoadingErrors

    public List<PrologTextLoaderError> getLoadingErrors()

### getPrologTextLoaderState

    public PrologTextLoaderState getPrologTextLoaderState()

### ensureLoaded

    public void ensureLoaded(Term term)

  Ensure that prolog text designated by term is loaded You must use `runInitialization(Interpreter)` after using this and before expecting answers.

  Parameters:
    `term` -
  See Also:
    `Predicate_ensure_loaded`

### createInterpreter

    public Interpreter createInterpreter()

  create interpreter for this environment Use this to create different `Interpreters` for different threads.

  Returns:
    an interpreter for this environment.

### getModule

    public Module getModule()

### loadPrologCode

    public PrologCode loadPrologCode(CompoundTermTag tag)
                              throws PrologException

  load code for prolog

  Parameters:
    `tag` - the tag of the `PrologCode` to load
  Returns:
    the loaded PrologCode
  Throws:
    `PrologException`

### getUndefinedPredicateCode

    public PrologCode getUndefinedPredicateCode(CompoundTermTag tag)

  get undefined predicate code

  Parameters:
    `tag` -
  Returns:
    undefined predicate code for the tag

### getPrologCode

    public PrologCode getPrologCode(CompoundTermTag tag)
                             throws PrologException

  get prolog code

  Parameters:
    `tag` -
  Returns:
    the `PrologCode` for the tag
  Throws:
    `PrologException`

### pollPrologCodeListeners

    protected void pollPrologCodeListeners()

### addPrologCodeListener

    public void addPrologCodeListener(CompoundTermTag tag,
                                      PrologCodeListener listener)

  add prolog code listener

  Parameters:
    `tag` -
    `listener` -

### removePrologCodeListener

    public void removePrologCodeListener(CompoundTermTag tag,
                                         PrologCodeListener listener)

  remove prolog code listener

  Parameters:
    `tag` -
    `listener` -

### predicateUpdated

    public void predicateUpdated(PredicateUpdatedEvent evt)

  Specified by:
    `predicateUpdated` in interface `PredicateListener`

### getDefaultInputStream

    public static InputStream getDefaultInputStream()

  Returns:
    the defaultInputStream

### setDefaultInputStream

    public static void setDefaultInputStream(InputStream defaultInputStream)

  Parameters:
    `defaultInputStream` - the defaultInputStream to set

### getDefaultOutputStream

    public static OutputStream getDefaultOutputStream()

  Returns:
    the defaultOutputStream

### setDefaultOutputStream

    public static void setDefaultOutputStream(OutputStream defaultOutputStream)

  Parameters:
    `defaultOutputStream` - the defaultOutputStream to set

### getOperatorSet

    public OperatorSet getOperatorSet()

### initStreams

    protected void initStreams(InputStream stdin,
                               OutputStream stdout)

### getUserInput

    public PrologStream getUserInput()
                              throws PrologException

  Throws:
    `PrologException`

### getUserOutput

    public PrologStream getUserOutput()
                               throws PrologException

  Throws:
    `PrologException`

### getCurrentInput

    public PrologStream getCurrentInput()
                                 throws PrologException

  Throws:
    `PrologException`

### getCurrentOutput

    public PrologStream getCurrentOutput()
                                  throws PrologException

  Throws:
    `PrologException`

### setCurrentInput

    public void setCurrentInput(PrologStream stream)
                         throws PrologException

  Throws:
    `PrologException`

### setCurrentOutput

    public void setCurrentOutput(PrologStream stream)
                          throws PrologException

  Throws:
    `PrologException`

### getStreamProperties

    public Map<PrologStream,List<Term>> getStreamProperties()
                                                     throws PrologException

  Throws:
    `PrologException`

### resolveStream

    public PrologStream resolveStream(Term stream_or_alias)
                               throws PrologException

  Throws:
    `PrologException`

### open

    public Term open(AtomTerm source_sink,
                     AtomTerm mode,
                     PrologStream.OpenOptions options)
              throws PrologException

  Throws:
    `PrologException`

### close

    public boolean close(PrologStream stream)
                  throws PrologException

  Parameters:
    `stream` -
  Returns:
    true if we closed and false if we did not close.
  Throws:
    `PrologException`

### closeStreams

    public void closeStreams()

  Closes all open streams

### getConversionTable

    public CharConversionTable getConversionTable()

  Returns:
    the convTable

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| GNU Prolog for Java
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD