Home >> All

• engine: Javadoc index of package engine.


Package Samples:

• engine

Classes:

• NameSpace: A symbol container. Its main task is name resolving: the algoithm is : 1. if a non-FQN (fully qualified name) is given, then it is resolved within the innermost module, by going up in the task/function/named block hierarcy. 2. if the name has the form . , then it is esolved as a downward reference: 2.a. look in the curent module for a module instance named ; if found, must be resolved within that instance 2.b. look in the parent module of the current module for a module instance called ; if found, then must be resolved within it 2.c. repeat step 2.b, mobing up in the hierarcy 3. try resolve the ...
• Strength: Constants & functions for strength manipulation. Strengths will be represented packed as a byte value, as follows: 7 0 +-+--------------+-+--------------+ |0| Strength0 |0| Strength1 | this is for an ambiguous signal (has both 0 & 1 strength) if the value is X, +-+--------------+-+--------------+ and for an unambiguous strength signal if value is other than X or: 7 0 \ +-+--------------+-+--------------+ | |1| MinStrength1 |0| MaxStrength1 | | these formats are for an unambiguous value +-+--------------+-+--------------+ | signal with ambiguous strength | (the first one for a 1 value , the second ...
• Result: Performs some useful conversions between DataHolders of various types. Is implemented by all DataHolders this is used to allow conversion between all types of data obtained as results of expression evaluation *NOTE* none of the operations that return a Result does not gurantees the integrity of the operands ( and often the returned Result is one of them). So, *do not* use them after one of these ! Use getxxx to make a copy when necessary.
• TranGateDescription: Transistors: [r]tran, [r]tranif(0|1) There is no associated TranGate class, since a tran is a pair of MContAssignMonitors (to which I have added reduceing strength capabiliies). Since the standard does not specify the exact behaviour of tran gates (no truth tables & stuff), I suppose the most probable one should be as foloows: if the control wire (we're spaking about tranif?) has any value other than 1, the tranif? is off.
• ModuleFactory: Used by ModuleInstnceDescription to create a new module instance by calling createNewModule on the descriptor. Its use is that provides a means of hiding the specific module interfacing mechanism (for an example UDPs have internal wires for ports while standard primitives are 'void', etc.) from the ModuleInstanceDescription, which is a common class to all module instances.
• MBiContAssignMonitor: This is a half of a bidirectional continuous assign monitor. It's used for inout ports (what else ??). Tha behaviour is as if the wirez were connected through a tran (but this is slightly faster than a bung on tran's for every port). A complete inout assignement is made of a pair of MBiContAssign... each acting in the other's opposite direction
• SimpleAssignInstruction: This is used to complete the non-blocking and wire assignement at the end of the time unit. It's not delayed. The value is determined at the time of the non-blocking assignement exectution, and the assignement is programmed by appending a SimpleAssignInstruction in the Time.finishList FIFO vector.
• AtInstruction: Implements the @(... OR ... ) instruction !! this executes ONLY ONE TIME PER Clock2 ! because it attaches to all monitors, and then detaches from all, all the values are updated, even if they were not producing the trigger. So, if they change in the same Clock2, nothing happens anymore.
• Monitor: Provides s is a simple way to communicate some state change between parts A monitor is a "thing" that surveys for an expression to gain some given value. When that happents, it should notify some threads that are waiting for this specific event ( the waiters).
• ModuleDescription: This contains the description of the inside structure of a module (regs, integers, threads of control, etc). Its main purpose is to creatye all the instances needed inside a module ( which in turn is created by ModuleInstanceDesscription.instantiate(..)).
• ConnectionDescription: A connection from inside a module to the outside world. It may contain a selection of ports bundled together under a single name visible from outside or an expression to be assigned to the port designated by the name (in a named parameter list).
• ContAssignMonitor: This is a monitor which waits for the rValue to change, and then takes care to modify lValue at the end of the time unit specified by the delay values (by posting a SimpleAssignInstruction). Note: only typical delays are used here.
• UserModuleDescription: A 'user module' is a module whose inner structure is accessible by the user (UDPs and modules). By contrast, standard primitives do not have an 'internal structure', and the links between ports are not made using intermediary DataHolders.
• ContBitSelect: This is a BitSelect that continuously assings to its target. Unless BitSelect, it maintains the bits in an internal BitVector ( data ), and calls Wire's compute(), in order for it to determine its bits considering all its assignemens;
• Delay3Description: Used as a structure to store a Delay3 Unless the standard, this is more permissive (i.e any constant expression is allowed). Also note that if some values are undefined, they are treated as 0 (no exceptions thrown).
• GenericInstruction: This is a placeholder for a runtime generated action (such as delayed value updates in monitors). An Executable can be plugged into a GenericInstruction so it can be scheduled at a later time.
• ModuleLoader: This class is used for dynamically loading modules from the known paths. It also contains the writeModule methos, which writes a module in the current working directory.
• TaskInstructionDescription: The description of a task activation instruction. It creates the required registers for the actual parameters (whose types are known only at instantiation time).
• ValueChangeMonitor: It's is a monitor that watches for the change of an expression, and then wakes up the associated thread (and, now and then, it gets stuck, i don't jnow why...)
• DisplayTask: This is the implementation of the $display task. Other tasks, such as $strobe, $write && stuff may also use this as a starting point.
• FunctionCallExpressionDescription: The description of a funcction call expression. It creates the required registers for the actual parameters (whose types are known only at instantiation time).
• LinkMonitor: Used for value propagation when strength are not a point (i.e.) a non-strength aware MContAssignMonitor. Used internally by std. gates for i/o replication.
• ProcAssignInstrucDescription: Implements the description of a procedural assignement ex: #1 a #2 = b ; //blocking or: b
• main: This class contains the entry points for the simulation engine: main, when running as a stand-alone application and runParser, whenn called by the IDE
• ASCII_CharStream: An implementation of interface CharStream, where the stream is assumed to contain only ASCII characters (without unicode processing).

Home | Contact Us | Privacy Policy | Terms of Service