prose-news Mailing List for PROSE Programming Language
Status: Pre-Alpha
Brought to you by:
cambridge
Menu
▾
▴
prose-news — News about the PROSE programming language
You can subscribe to this list here.
| 2004 |
Jan
|
Feb
|
Mar
|
Apr
(1) |
May
|
Jun
|
Jul
|
Aug
(1) |
Sep
|
Oct
|
Nov
|
Dec
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2009 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(2) |
Oct
|
Nov
|
Dec
|
| 2010 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
(1) |
| 2011 |
Jan
(1) |
Feb
(2) |
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
(1) |
Dec
|
| 2012 |
Jan
|
Feb
(1) |
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(2) |
Oct
|
Nov
|
Dec
|
| 2013 |
Jan
|
Feb
|
Mar
(1) |
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
| 2016 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
(1) |
Jul
|
Aug
|
Sep
|
Oct
|
Nov
|
Dec
|
| 2017 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
|
Nov
|
Dec
|
|
From: News a. t. P. p. l. <pro...@li...> - 2017-09-21 22:39:01
|
PROSE 0.11.0 has been released this week and is an update to 0.10.x. Release 0.11.0 introduces virtual branches, ps_file, ps_time and ps_stream. Virtual branches allow data to appear to be attached to the nexus when it really isn't. This is achieved using "class hooks" in the back-end modules. When an object class is assigned to an object that is marked as a "class hook", then child nodes sought beneath that object are created dynamically on request via API calls to the relevant back-end module. The hooks discussed in the src/prose/modules/README file. The ps_file module is also introduced in this release and is documented in the ps_file(5) man page. This makes use of the new virtual branch functionality to allow filesystems to appear as objects in the nexus. All of the data made available via the UNIX stat(2) system call may be exposed via virtual attributes on these objects, which may be written to as well as read from where it makes sense. The ps_time module is introduced as well as the psTime variable type. This allows time to be represented and for time calculations to be performed using LDAP generalized time format (RFC4517). Time is stored internally as a 128-bit GMP floating point number. This was required primarily so that the ps_file module could represent modification dates on files. The ps_stream module has been introduced that builds functionality on top of file objects produced by the ps_file module, and is described in the ps_stream(5) man page. This supports all of the basic I/O operations required to open and close files, and to read and write to file streams. It also comes with support for the standard file streams: stdin, stdout, stderr and stdbug. LDAP schema enforcement has been increased, as it is now not possible for an object to have more than one structural class assigned to it. The psFloat default precision has been changed from 64 bits to 128 bits. It is not yet possible to change the precision from within PAL. From the PAL side, the obj/commitref, obj/refresh and reg/xload instructions are new, while reg/scan has been renamed to reg/xscan. See pal_commands(5). Instructions that handled lengths of strings now support psInteger for the size arguments instead of just psIndex as they did previously, removing the 32-bit limit on the length of the string manipulation operations. The lexer has also been fixed for octal numbers that start with a 0 prefix. PROSE can be compiled and run on a variety of UNIX and UNIX-like systems including Oracle Solaris, Fedora Linux, Debian Linux, SuSE Linux, Ubuntu Linux, FreeBSD, MacOS, DJGPP (MS-Windows/DOS) and the RaspberryPi (ARM). This is a pre-alpha release, containing a fully functional assembler and disassembler for an evolving assembly language (PAL), which compiles into a platform-independent bytecode. A bytecode interpreter (the PROSE engine) is also included in this release. At this time there is no high-level language. For more information about the PROSE Programming Language, visit http://prose.sourceforge.net. - Mark R. Bannister |
|
From: News a. t. P. p. l. <pro...@li...> - 2016-06-07 20:49:38
|
PROSE 0.10.0 has been released this week is an update to 0.9.x. It features some major changes to the inner workings of the PROSE engine to make it even more robust, in particular that references to nodes in the nexus (object references) are now tracked. This makes it possible to avoid potential core dump scenarios where a pointer to a node is obtained, the node then deleted, then the pointer de-referenced. When debugging an application it is also possible to list all object references that were not released properly when the program exits as well as reporting where those references are held so that the offending code can be pin-pointed. It is also now possible to safely overwrite any register type, and any type of data if left in a register will be cleaned up correctly upon return from a function. This has meant that the '--enable-regscan' configure option and the RegisterViolation error became redundant and have been removed. PROSE can be compiled and run on a variety of UNIX and UNIX-like systems including Oracle Solaris, Fedora Linux, Debian Linux, SuSE Linux, Ubuntu Linux, FreeBSD, MacOS, DJGPP (MS-Windows/DOS) and has also been tested on the RaspberryPi (ARM). This is a pre-alpha release, containing a fully functional assembler and disassembler for an evolving assembly language (PAL), which compiles into a platform-independent bytecode. A bytecode interpreter (the PROSE engine) is also included in this release. At this time there is no high-level language. For more information about the PROSE Programming Language, visit http://prose.sourceforge.net. - Mark R. Bannister Email: cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2013-03-17 01:14:02
|
PROSE 0.9.0 has been released today which is a major update to 0.8.x. The new release introduces tree arrays, documented in the ps_tree(5) man page within the distribution, and various other improvements discussed in the Release Notes, see http://prose.sourceforge.net/release.html. For more information about the PROSE Programming Language, visit http://prose.sourceforge.net <http://prose.sourceforge.net>. - Mark R. Bannister Email: cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2012-09-21 16:36:43
|
The first PAL tutorial since the release of PROSE 0.8.0 has been released on SourceForge, demonstrating the power and flexibility of the new matrix array functionality. To try out this new tutorial, visit: http://sourceforge.net/apps/mediawiki/prose/index.php?title=Matrix_arrays Note that this tutorial will require at least the updated patch release 0.8.1, available from: http://sourceforge.net/projects/prose/files/latest/download - Mark R. Bannister Email:cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2012-09-21 16:17:28
|
PROSE 0.8.1 has been released today which is a minor update to 0.8.1. It's main purpose is to fix a few bugs, mainly relating to occasional core dumps. For more information about the PROSE Programming Language, visithttp://prose.sourceforge.net. - Mark R. Bannister Email:cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2012-02-17 22:07:50
|
PROSE 0.8.0 has been released today which is a major update to 0.7.x. The new release introduces list sequences, matrix arrays and virtual attributes. These features make the bytecode more expressive and more powerful, allowing arguments to be grouped together so that instructions can more readily take a variable number of inputs, the release adds powerful control over contiguous blocks of memory, and expands the LDAP object model to allow attributes to contain dynamic data. The new features are currently documented in the list_def(5) and mtx_def(5) man pages within the distribution. The online documentation and tutorials will be updated soon. For more information about the PROSE Programming Language, visit http://prose.sourceforge.net. - Mark R. Bannister Email: cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2011-11-09 18:50:16
|
The PROSE Programming Language has now migrated across from CVS to Mercurial. The CVS repository is still available as historical reference, although no more changes will be made to it. One advantage of a move to a distributed SCM solution is that I'll be able to commit my changes much more regularly, while on the train, and not have to worry about a network connection. I can then push my changes back to SourceForge as and when I have a network, and hopefully more regularly than in the past. I am still working furiously on PROSE version 0.8.0, which I hope to release before the onset of 2012. I can no longer commit to having tree arrays working this year, although I will hope to have much of the matrix array functionality completed. - Mark R. Bannister. |
|
From: News a. t. P. p. l. <pro...@li...> - 2011-02-15 22:12:07
|
The reference manual pages for the PROSE Programming Language are now available online again, after a long and sore absence. They can be browsed from the following URL: http://prose.sourceforge.net/man For more information about the PROSE Programming Language, visit http://prose.sourceforge.net. - Mark R. Bannister Email: cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2011-02-15 22:10:30
|
PROSE 0.7.1 has been released today which is a minor update to 0.7.0. The most significant change in this point release is to the grammar checking when PAL source files are assembled, which has been greatly improved. This will make it easier to spot errors at assembly time, rather than at runtime. There have also been one or two minor bug fixes. If you downloaded PROSE 0.7.0, it's worth pulling down this update. If you didn't download PROSE 0.7.0, it's definitely worth checking out the new features and the new tutorials, as a lot has changed since previous releases. For more information about the PROSE Programming Language, visit http://prose.sourceforge.net. - Mark R. Bannister Email: cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2011-01-07 11:15:34
|
------------------------------------------------------------------------------ 7 January 2011, prose-0.7.0 A new tutorial is now available on the PAL tutorial pages. This walks through creating an arbitrary-precision calculator which takes simple two-operand maths instructions on standard input and returns the resulting computation to standard output. It demonstrates writing a PAL program that will allow for simple two-operand calculations on integers, floating-point numbers and rational numbers. It also demonstrates the use of variables and functions as well as basic integration with the GNU MP library. The tutorial is available from the tutorial index page: http://sourceforge.net/apps/mediawiki/prose/index.php?title=PAL_tutorials Happy New Year! - Mark R. Bannister Email: cam...@us... |
|
From: News a. t. P. p. l. <pro...@li...> - 2010-12-27 15:10:53
|
------------------------------------------------------------------------------
27 December 2010, prose-0.7.0
PROSE is a cross-platform programming environment designed to simplify the development of small and large-scale networked applications. It will comprise of a scripting language which compiles into bytecode and an execution engine that interprets that bytecode. The execution engine will be designed to communicate easily with other PROSE engines across the network. The inter-networking capabilities will be made available at the bytecode level via virtual nodes in a hierarchical object tree (the 'nexus').
This is a pre-alpha POC release, containing a fully functional assembler and disassembler for an evolving assembly language (PAL), which compiles into a platform-independent bytecode. A bytecode interpreter (the PROSE engine) is also included in this release. At this time there is no scripting language.
PROSE can be compiled and run on a variety of UNIX and UNIX-like systems including Oracle Solaris, Red Hat Linux, SuSE, Ubuntu, FreeBSD, MacOS and DJGPP (MS-Windows/DOS).
The following features have been introduced since the previous version:
VARIABLES
It is now possible to declare variables. Variables are represented as nodes in the nexus that include the class psVariable. The types supported are:
* psString: String data.
* psIndex: Raw index (32-bit unsigned integer).
* psPointer: Pointer to a node in the nexus.
* psInteger: Arbitrary precision GMP integer.
* psFloat: Multi-precision GMP floating-point number.
* psRational: Arbitrary precision GMP rational number.
Variables can be declared using the var/def, var/local, var/static or var/global instructions. See var_def(5). Local variables may also be created automatically when a function is called, see FUNCTIONS below.
As a result of these changes, PROSE now requires the GMP library 'libgmp'.
ENCODED VALUES
Data may now be passed around in registers in encoded form, that is, a value may be encoded with an appropriate syntax, suitable for a particular attribute, and stored in a register before being attached to an object. An encoded value may be created using the attr/def or attr/xcopy instructions. It is represented by the type PSUNIT_TYPE_XVALUE and often referred to as an XVALUE. See attr_def(5) and attr_xvalue(5).
MATHS
A suite of instructions have been introduced that allow maths operations to be performed on raw indices and GMP numbers (integers, floats and rationals) via the back-end module APIs. The instructions beginning op/ and opa/ operate on raw indices as before, while sister instructions opo/ operate on variable objects and opx/ on encoded values (XVALUEs). See op_maths(5), opa_maths(5), opo_maths(5) and opx_maths(5).
FUNCTIONS
Functions may now be declared with up to 14 formal parameters, and may return a value. The parameters are declared with the func/def instruction, which defines the type and name of each parameter. When the function is invoked, the parameters will be automatically created as variables within local scope of the function, underneath the instance container. See func_def(5).
Values may now also be returned from functions. The return type is declared by the func/def instruction. The value is always returned as an XVALUE. See func_rtn(5).
The func/call and func/bcall instructions have been modified to specify which register should contain the returned value, and to provide arguments to function parameters. See func_call(5).
REGISTERS
The number of addressable registers has been expanded again so that P0 to P15 are all usable. A new special register PERR has been introduced to hold the error type when an error handler is called, rather than using P13 as in the previous release.
EQUI MACRO
A data segment may now additionally use the EQUI macro to input raw indices. This is a collection of 32-bit unsigned integers, and is functionally equivalent to EQUD except that the data is stored more efficiently for numbers in the hexadecimal range 0 to ffff.
BYTECODE CHANGES
A number of changes to the bytecode format will mean that this version is not binary compatible to previous versions of PROSE. Specifically, there is no longer a special encoding for the Accumulator (A) register. Instead, opcode modifiers have been introduced which greatly increase the number of available opcodes. If the byte immediately following an opcode has bit 5 set, then it is an opcode modifier and serves to modify the behaviour of the instruction. This feature is currently used with the maths operations.
FUTURE RELEASES
Arrays, hashes and collections are targetted for the next release. This will extend variable objects such that larger amounts of related data can be easily stored and manipulated.
Future releases will introduce virtual nodes and branches in the nexus that will allow access to external data using the object manipulation commands already available. This will include navigating filesystems, opening/closing files, querying DNS, opening network connections and manipulating databases. Virtual nodes and branches will be extendable using modules to permit any kind of data to be represented through the nexus.
Also missing at this time is any glimpse of the future PROSE scripting language. This will have to wait until the PAL bytecode provides enough of the required functionality.
COMPATIBILITY
While PROSE remains in pre-alpha, it is not possible to guarantee PAL source or binary compatibility between releases.
PAL source files written for earlier versions of PROSE will not compile in version 0.7.0 without modification if they defined or called functions, or if they expect register P13 in an error handler to contain a pointer to the error type. As previously mentioned, the function instructions have been modified to support formal parameters and returning values, and the register PERR has been introduced for error handlers.
PROSE binary files compiled by earlier versions of the prism tool will not run in version 0.7.0. Subject to the modifications above, all source files will need to be re-compiled. This is due to a change in the bytecode format that was required to introduce opcode modifiers.
To learn more about the PROSE Programming Language, visit http://prose.sourceforge.net.
PROSE is released with detailed manual pages that describe how PAL operates, and how each instruction is used. These manual pages can be read using the man command, for example man pal_intro or man pal_commands, or from the SourceForge website.
- Mark R. Bannister
Email: cam...@us...
|
|
From: News a. t. P. p. l. <pro...@li...> - 2009-09-17 16:43:46
|
There are some new tutorials available now for the PROSE Assembly Language (PAL). These tutorials will walk you through objects, classes and attributes as well as writing some example programs. The tutorials are available at http://prose.sourceforge.net/tutorials. |
|
From: News a. t. P. p. l. <pro...@li...> - 2009-09-11 10:40:01
|
------------------------------------------------------------------------------
11 September 2009, prose-0.5.0
PROSE is a cross-platform programming environment designed to simplify the
development of small and large-scale networked applications. It will
comprise
of a scripting language which compiles into bytecode and an execution engine
that interprets that bytecode. The execution engine will be designed to
communicate easily with other PROSE engines across the network. The
inter-networking capabilities will be made available at the bytecode level
via virtual nodes in a hierarchical object tree (the 'nexus').
This is a pre-alpha POC release, containing a fully functional assembler and
disassembler for an evolving assembly language (PAL), which compiles into a
platform-independent bytecode. A bytecode interpreter (the PROSE engine) is
also included in this release. At this time there is no scripting language.
The current release is known to compile and run on the following platforms:
* Sun Solaris 8
* Sun Solaris 10
* DJGPP 2.03 (MS-Windows/DOS)
* Redhat Linux (FC11)
* SuSE Linux (SLED10)
Previous versions have also been tested on FreeBSD 6.x and MacOS 10.x, and I
expect it still works on these too. If you have it up-and-running on a
different platform, please let me know.
The PAL assembly language is taking more significant shape now. The
PROSE engine is interpreting many more bytecode instructions than with the
previous release. These instructions are described in section 5 man pages
which are distributed with this release, and HTML versions of these
man pages can be viewed at http://sourceforge.net/project/prose.
This version of PROSE can handle the following PAL instructions.
Those marked * are new to this release:
noop No operation
stack/push Push data onto program stack
stack/pull Pull data from program stack
stack/lock Lock program stack
stack/unlock Unlock program stack
stack/flush Flush program stack up to last lock
*obj/def Define new object edit buffer
*obj/clone Clone existing object
*obj/edit Edit existing object
*obj/commit Commit changes in object edit buffer
*obj/del Delete object
*obj/addr Lookup object
*obj/pa Lookup parent object
obj/dump Debug object
*class/add Add class directly or via object edit buffer
*class/del Delete class directly or via object edit buffer
*class/load Load object class definitions or assignments
*class/test Test object for a list of classes
*attr/add Add attribute directly or via object edit buffer
*attr/del Delete attribute directly or via object edit buffer
*attr/mod Modify attribute directly or via object edit buffer
*attr/mvadd Attribute multi-value add
*attr/mvdel Attribute multi-value delete
*attr/mvmod Attribute multi-value modify
*attr/copy Copy attribute values
*attr/direct Direct attribute-to-attribute copy
*attr/load Load attribute definitions or assignments
*attr/test Test object for a list of attributes
*attr/mvtest Test object for a list of multiple attribute values
*op/incr Increment numeric register by 1
*op/decr Decrement numeric register by 1
*op/add Add numeric registers
*opa/add Add numeric registers to Accumulator
*op/sub Subtract numeric registers
*opa/sub Subtract numeric registers from Accumulator
*op/mult Multiply numeric registers
*opa/mult Multiply Accumulator by numeric registers
*op/div Divide numeric registers
*opa/div Divide Accumulator by numeric registers
*op/mod Calculate remainder
*opa/mod Calculate remainder with Accumulator
*op/and Logical AND
*opa/and Logical AND with Accumulator
*op/or Logical OR
*opa/or Logical OR with Accumulator
*op/xor Logical exclusive OR
*opa/xor Logical exclusive OR with Accumulator
*op/shl Bitwise shift left
*opa/shl Bitwise shift left with Accumulator
*op/shr Bitwise shift right
*opa/shr Bitwise shift right with Accumulator
*op/mask Generate a 32-bit mask
*op/swap Swap bytes
error/def Define a new error type
error/now Generate a new error condition
error/jmp Adds/removes error handlers
error/clr Clear existing error condition
func/def Initialise a function
func/call Execute a function, zeroing registers
func/bcall Execute a function, saving and restoring registers
func/rtn Return from a function
local/jmp Jump to code
local/jsr Branch to code
local/rtn Return from code branch
reg/load Loads data into registers
*reg/save Modify sections of text or byte strings
*reg/copy Copy or concatenate text arguments
*reg/conv Convert between raw indices and strings
*reg/move Move data between registers
reg/jmpeq Jump to code if comparison is true
reg/jmpneq Jump to code if comparison is not true
reg/jsreq Branch to code if comparison is true
reg/jsrneq Branch to code if comparison is not true
reg/dump Debug register
*reg/clr Safely clear register contents
*reg/index Read internal data table index number
*reg/cmp Compare registers
*reg/lcmp Rolling left comparison
*reg/rcmp Rolling right comparison
*reg/scan Search test or byte strings
debug/source Define source file and source line data for
stack traces and debuggers
*debug/level Set debug level
You can define data segments within binaries using the following macros.
Those marked * are new to this release:
EQUS Enters a sequence of ASCII characters
EQUB Enters a sequences of bytes
EQUW Enters a sequence of 16-bit words
EQUD Enters a sequence of 32-bit words
*EQUP Enters a sequence of code or data pointers
The following system objects are supported in this release:
.prose.io Access 4 different input/output streams
This release introduces the ability to create and delete objects, assign
classes and attributes and query objects. Maths instructions are now
available for basic maths operations on 32-bit raw indices. There are
also a number of different options available for manipulating registers and
byte strings. The '.prose.io' object in the nexus allows for reading and
writing to standard input, output and error. Indirect addressing modes
extend the functionality of some of the bytecode instructions so that lists
and tables may be manipulated, including data segments defined with the
data entry macros EQUS, EQUB, EQUW, EQUD and EQUP.
The 'walker' instructions in the previous release used for iterating nodes
in the nexus have been replaced by 'reg/load' in one of its indirect
addressing modes. See the reg_load_walker(5) man page.
In this release, the number of addressable registers has been reduced to 15.
There are 14 'P' registers (P0 to P13) and the Accumulator 'A'. The
Accumulator
has been introduced to allow for abbreviated bytecode when manipulating
numeric registers.
Future releases will introduce variables, with configurable rules for
data encoding. Variables will extend the functionality of the PAL bytecode
significantly. A variable will be represented as an object in the nexus
attached underneath the current executing object. With variables will come
the ability to pass data to functions and return data from functions -
all at the bytecode level.
Also set for future development are virtual nodes and branches in the nexus
that will allow access to all kinds of external data using the object
manipulation commands already available. This will include navigating
filesystems, opening/closing files, querying DNS, opening network
connections
and manipulating databases. Virtual nodes and branches will be extendable
using modules to permit any kind of data to be represented through the
nexus.
Also missing at this time is any glimpse of the future PROSE scripting
language. This will have to wait until the PAL bytecode provides enough of
the required functionality.
- Mark R. Bannister
Email: cam...@us...
------------------------------------------------------------------------------
|
|
From: <pro...@li...> - 2004-08-30 21:47:01
|
The first packaged release of PROSE (0.0.3) has been made available at _http://sourceforge.net/projects/prose_ (http://sourceforge.net/projects/prose) . This includes prism, a fully working assembler and disassembler for the PROSE Assembly Language, which can now be used as a proof-of-concept tool. The release also includes libIvor and libpal, two low-level libraries that can be used by other tools and compilers to reduce time to market. PROSE is a new hierarchical programming language in the design and prototyping stage, with the goal of easing the development of small and large-scale networked applications. - Mark R. Bannister, 30 August 2004. ----------------------------------------- Mark R.Bannister, Author, Programmer, I.T. Consultant and Musician. Email: ma...@fr... Website: www.freedomware.co.uk ----------------------------------------- |
|
From: <pro...@li...> - 2004-04-29 21:59:18
|
The latest PROSE specification has been released and can be downloaded from http://prose.sourceforge.net. In an attempt to clarify to the community at large why PROSE is important, I am also now simplifying the description of the language to highlight its benefits to developing small and large-scale networked applications. This reflects its true position in the industry, where it is ever-increasingly important for systems to talk together and integrate seamlessly. Best regards, Mark. ----------------------------------------- Mark R.Bannister, Author, Programmer, I.T. Consultant and Musician. Email: ma...@fr... Website: prose.sourceforge.net ----------------------------------------- |