@lpc-lang/core 1.1.2-5.1

package/src/efuns/fluffos/parsing.h

@@ -0,0 +1,220 @@
+// parsing.h
+
+/**
+ * query_verb() - return the name of the command currently being executed
+ *
+ * Give the name of the current command, or 0 if not executing from a com‐
+ * mand.  This function is useful when several commands (verbs) may  cause
+ * the  same  function  to  execute and it is necessary to determine which
+ * verb it was that invoked the function.
+ *
+ */
+string query_verb( void );
+
+/**
+ * process_value() - give a value from a described function call
+ *
+ * Get  the  replacement  of  one syntactic pattern. The pattern is on the
+ * form:
+ * 
+ * "function[:filename][|arg1|arg2....|argN]"
+ * 
+ * The returned value can be of any type.
+ * 
+ * Note that both object and arguments are marked optional with the brack‐
+ * ets and that the brackets are not included in the actual pattern.
+ *
+ */
+mixed process_value( string calldescription );
+
+/**
+ * process_string() - give a string with replaced calldescriptions
+ *
+ * Processes  a  string by replacing specific syntactic patterns with what
+ * is returned when the pattern is interpreted as a function call descrip‐
+ * tion.
+ * 
+ * The syntactic patterns are on the form:
+ * 
+ * "@@function[:filename][|arg1|arg2....|argN]@@"
+ * 
+ * This is interpreted as a call:
+ * 
+ * filename->function(arg1, arg2, ....., argN)
+ * 
+ * Note  that  process_string  does  not recurse over returned replacement
+ * values. If a function returns another syntactic pattern, that  descrip‐
+ * tion will not be replaced.
+ * 
+ * All  such  occurrences  in 'combinestring' is processed and replaced if
+ * the return value is a string. If the return value is not a  string  the
+ * pattern will remain unreplaced.
+ * 
+ * Note that both object and arguments are marked optional with the brack‐
+ * ets and that the brackets are not included in the actual pattern.
+ *
+ * A string:
+ * "You are chased by @@query_the_name:/obj/monster#123@@ eastward."
+ * 
+ * is replaced by:
+ * "You are chased by the orc eastward."
+ * 
+ * Assuming that query_the_name in monster#123 returns "the orc".
+ *
+ */
+string process_string( string combinestring );
+
+/**
+ * parse_sentence() - parse the command contained in the given string
+ *
+ * This efun calls the driver parser and tells it to parse and execute the
+ * command contained in the given string. The efun may return an integer
+ * error code, or a string error message. If a string message is returned,
+ * it should be displayed to the player. The integer codes are:
+ * 
+ * * 1: command has been processed ok
+ * * 0: no matching command was found, no processing done
+ * * -1: A matching command was found but none of its rules were matched.
+ * * -2: A rule made sense but all "can" or "direct" applies returned 0.
+ *
+ */
+mixed parse_sentence(string, void | int, void | object *, void | mapping);
+
+/**
+ * parse_refresh()
+ *
+ * The parsing package caches information about objects in order to improve
+ * performance. This means that if any information that gets cached is
+ * changed, you need to tell MudOS to clear the cache. That's what this efun
+ * does. If the information returned by any of the applies below changes, you
+ * need to call parse_refresh() so that the parser knows it has changed. For
+ * example if the name of an object changes, or perhaps an adjective changes
+ * as a spell is cast to change it from blue to red - call parse_refresh()
+ * afterwards. The efun clears the cache for the object that called it.
+ *
+ */
+void parse_refresh();
+
+/**
+ * parse_init()
+ *
+ * The efun parse_init() is used to tell MudOS that this object is one
+ * that may use or be used by the parsing package. If your object does
+ * not call this then trying to use other parsing efuns will generate a
+ * runtime error and the parser will ignore the object when searching
+ * for matches. Suggest call parse_init() from create() in the standard
+ * object.
+ *
+ */
+void parse_init();
+
+/**
+ * parse_command() - try to match a string with a given pattern
+ *
+ * parse_command()  is  a piffed up sscanf(3) operating on word basis.  It
+ * works similar to sscanf(3) in that it takes a pattern  and  a  variable
+ * set  of  destination  arguments. It is together with sscanf(3) the only
+ * efun to use pass by reference for other variables  than  arrays.   That
+ * is, parse_command() returns values in its arguments.
+ * 
+ * parse_command()  returns  1  if 'command' is considered to have matched
+ * 'pattern'.
+ * 
+ * The 'env' or 'oblist' parameter either holds an object  or  a  list  of
+ * objects.  If  it holds a single object than a list of objects are auto‐
+ * matically created by adding the deep_inventory of the object,  ie  this
+ * is identical:
+ * 
+ * parse_command(cmd, environment(), pattern, arg)
+ * 
+ * and
+ * 
+ * parse_command( cmd, ({ environment() }) +
+ * deep_inventory(environment()), pattern, arg)
+ * 
+ * 'pattern' is a list of words and formats:
+ * 
+ * Example string = " 'get' / 'take' %i "
+ * Syntax:
+ * 'word'          obligatory text
+ * [word]          optional text
+ * /               Alternative marker
+ * %o              Single item, object
+ * %l              Living objects
+ * %s              Any text
+ * %w              Any word
+ * %p              One of a list (prepositions)
+ * %i              Any items
+ * %d              Number 0- or tx(0-99)
+ * 
+ * The  'arg'  list  is zero or more arguments. These are the result vari‐
+ * ables as in sscanf. Note that one variable is needed for each %_
+ * 
+ * The return types of different %_ is:
+ * %o      Returns an object
+ * %s      Returns a string of words
+ * %w      Returns a string of one word
+ * %p      Can on entry hold a list of word in array
+ * or an empty variable
+ * Returns:
+ * if empty variable: a string
+ * if array: array[0] = matched word
+ * %i      Returns a special array on the form:
+ * [0] = (int) +(wanted) -(order) 0(all)
+ * [1..n] (object) Objectpointers
+ * %l      Returns a special array on the form:
+ * [0] = (int) +(wanted) -(order) 0(all)
+ * [1..n] (object) Objectpointers
+ * These are only living objects.
+ * %d      Returns a number
+ * 
+ * The only types of % that uses  all  the  loaded  information  from  the
+ * objects  are %i and %l. These are in fact identical except that %l fil‐
+ * ters out all nonliving objects from the list of objects  before  trying
+ * to parse.
+ * 
+ * The return values of %i and %l is also the most complex. They return an
+ * array consisting of first a number and then all possible objects match‐
+ * ing.   As  the  typical  string matched by %i/%l looks like: 'three red
+ * roses', 'all nasty bugs' or 'second blue sword'  the  number  indicates
+ * which of these numerical constructs was matched:
+ * 
+ * if numeral >0 then three, four, five etc were matched
+ * if numeral <0 then second, twentyfirst etc were matched
+ * if numeral==0 then 'all' or a generic plural form such as
+ * 'apples' were matched.
+ *
+ * if (parse_command("spray car",environment(this_player()),
+ * " 'spray' / 'paint' [paint] %i ",items))
+ * {
+ * /*
+ * If the pattern matched then items holds a return array as
+ * described under 'destargs' %i above.
+ * *\/
+ * }
+ *
+ */
+int parse_command( string command, object|object* env,
+                   string pattern, mixed arg... );
+
+/**
+ * parse_add_rule() - add parsing rules for a verb
+ *
+ * Here "verb" is the command word (e.g. "look", "read" etc), The "rule" is
+ * the parsing rule to add. Rules are made up from two parts - tokens, and
+ * prepositions. Tokens are used to match various objects or strings, and
+ * prepositions are fixed positional words to specify meaning (like "with"
+ * or "in").
+ * 
+ * The MudOS accepts six tokens that I'm aware of:
+ * 
+ * OBJ - matches a single object
+ * OBS - matches one or more objects
+ * LIV - matches a single, living object
+ * LVS - matches one or more living objects
+ * WRD - matches a single word
+ * STR - matches one or more words
+ *
+ */
+void parse_add_rule(string verb, string rule);
+

package/src/efuns/fluffos/pcre.h

@@ -0,0 +1,75 @@
+// pcre.h
+
+/**
+ * pcre_version() - returns the version of the compiled PCRE library used
+ *
+ * returns the version of the compiled PCRE library used
+ *
+ */
+string pcre_version(void);
+
+/**
+ * pcre_replace_callback() - string replace uses a callback to get the replace string
+ *
+ * returns a string where all captured groups have been replaced by the return
+ * value of function pointer fun or function fun in object ob. (called with the
+ * matched string and match number, starting with 0)
+ *
+ */
+string pcre_replace_callback(string input, string pattern, string|function, mixed *args...);
+
+/**
+ * pcre_replace()
+ *
+ * returns a string where all captured groups have been replaced by the
+ * elements of the replacement array. Number of subgroups and the size of the
+ * replacement array must match.
+ *
+ */
+string pcre_replace(string input, string pattern, string *replacments);
+
+/**
+ * pcre_match_all() - find all matches
+ *
+ * Similiar to php preg_match_all, this EFUN returns a array of string arrays,
+ * containing all matches and captured groups.
+ *
+ */
+mixed pcre_match_all(string input, string pattern);
+
+/**
+ * pcre_match() - regular expression handler
+ *
+ * analog with regexp efun for backwards compatibility reasons but utilizing
+ * the PCRE library.
+ *
+ */
+mixed pcre_match(string|string *lines, string pattern, void|int flag);
+
+/**
+ * pcre_extract() - extract matching parts
+ *
+ * returns an array of captured groups specified in pattern.
+ *
+ */
+string *pcre_extract(string input, string pattern);
+
+/**
+ * pcre_cache() - return content of the pcre cache
+ *
+ * returns content of the pcre cache (not all that useful).
+ *
+ */
+mapping pcre_cache(void);
+
+/**
+ * pcre_assoc() - A regular pattern substring extractor
+ *
+ * analog with reg_assoc efun for backwards compatibility reasons but utilizing
+ * the PCRE library.
+ *
+ */
+varargs mixed *pcre_assoc(string input, string *patterns, 
+    mixed *token_aray, 
+    mixed default_value);
+

package/src/efuns/fluffos/sockets.h

@@ -0,0 +1,276 @@
+// sockets.h
+
+/**
+ * socket_write() - send a message from a socket
+ *
+ * socket_write()  sends  a  message  on a socket s. If the socket s is of
+ * type STREAM or MUD, the  socket  must  already  be  connected  and  the
+ * address  is  not  specified.  If  the  socket  is of type DATAGRAM, the
+ * address must be specified.  The address is of the form: "127.0.0.1 23".
+ *
+ */
+int socket_write( int s, mixed message,
+                  void | string address );
+
+/**
+ * socket_status() - display the status of each LPC socket
+ *
+ * socket_status() returns an array of arrays; one for each socket.
+ *
+ */
+mixed *socket_status(void | int);
+
+/**
+ * socket_release() - release ownership of a socket to another object
+ *
+ * socket_release()  is used to change ownership (and control) of a socket
+ * to another object.  It is useful in daemon objects (like  inetd)  which
+ * handle  connection  set-up  and  then  transfer  a  connected socket to
+ * another object for further processing.
+ * 
+ * Socket ownership transfer involves  a  handshake  between  the  current
+ * owner object and the socket to which the current owner wishes to trans‐
+ * fer the socket.  The handshake is initiated  when  socket_release()  is
+ * called.   socket_release() does appropriate security/integrity checking
+ * and then calls the release_callback function in object ob.  This  func‐
+ * tion is used to notify ob that socket ownership is being transferred to
+ * it.  It is then ob's responsibility to call socket_acquire() within the
+ * release  callback  function.   If  socket_acquire()  is called then the
+ * handshake is complete and socket ownership has been successfully trans‐
+ * ferred  to  ob.  ob may decline to accept responsibility for the socket
+ * by not calling socket_acquire(),  in  which  case  ownership  does  not
+ * change and the current socket owner must decide how to respond to this.
+ * 
+ * If  the  socket  owner is successfully transfered then socket_release()
+ * returns EESUCCESS.  If ob does not accept ownership for the socket then
+ * EESOCKNOTRLSD is returned.  Other errors can be returned based on secu‐
+ * rity violation, bad socket descriptor vbalues, etc.
+ *
+ */
+int socket_release( int socket, object ob,
+                    string release_callback );
+
+/**
+ * socket_listen() - listen for connections on a socket
+ *
+ * To accept connections, a socket is first created with socket_create(3),
+ * the socket is them put into listening mode with  socket_listen(3),  and
+ * the connections are accepted with socket_accept(3). The socket_listen()
+ * call applies only to sockets of type STREAM or MUD.
+ * 
+ * The argument listen_callback is the name of a function for  the  driver
+ * to  call  when  a  connection is requested on the listening socket. The
+ * listen callback should follow this format:
+ * 
+ * void listen_callback(int fd)
+ * 
+ * Where fd is the listening socket.
+ *
+ */
+
+
+int socket_listen( int s, string listen_callback );
+
+/**
+ * socket_error() - return a text description of a socket error
+ *
+ * socket_error()  returns  a  string  describing  the  error signified by
+ * error.
+ *
+ */
+
+
+string socket_error( int error );
+
+/**
+ * socket_create() - create an efun socket
+ *
+ * socket_create()  creates  an efun socket. mode determines which type of
+ * socket is created. Currently supported socket modes are:
+ * 
+ * 0  MUD             for sending LPC data types using TCP protocol.
+ * 
+ * 1  STREAM          for sending raw data using TCP protocol.
+ * 
+ * 2  DATAGRAM        for using UDP protocol.
+ * 
+ * 3  STREAM_BINARY   for exchange binary message with TCP protocol.
+ * 
+ * 4  DATAGRAM_BINARY for exchange binary message with UDP protocol.
+ * 
+ * The argument read_callback is the name of a function for the driver  to
+ * call  when the socket gets data from its peer. The read callback should
+ * follow this format:
+ * 
+ * void read_callback(int fd, mixed message, string addr)
+ * 
+ * Where fd is the socket which received the data, and message is the data
+ * which was received, addr is the client address.
+ * 
+ * In non-binary mode, message will be sanitized with UTF8 encoding and returned as an string.
+ * 
+ * In binary mode, raw messages will be returned as a buffer.
+ * 
+ * The argument close_callback is the name of a function for the driver to
+ * call if the socket closes unexpectedly, i.e. not as  the  result  of  a
+ * socket_close(3) call. The close callback should follow this format:
+ * 
+ * void close_callback(int fd)
+ * 
+ * Where  fd  is the socket which has closed.  NOTE: close_callback is not
+ * used with DATAGRAM mode sockets.
+ *
+ */
+int socket_create( int mode, string read_callback,
+                   void | string close_callback );
+
+/**
+ * socket_connect() - initiate a connection on a socket
+ *
+ * The  argument  s  is  a socket. s must be either a STREAM mode or a MUD
+ * mode socket. address is the address to which the socket will attempt to
+ * connect.  address is of the form: "127.0.0.1 23"
+ * 
+ * The  argument read_callback is the name of a function for the driver to
+ * call when the socket gets data from its peer. The read callback  should
+ * follow this format:
+ * 
+ * void read_callback(int fd, mixed message)
+ * 
+ * Where fd is the socket which received the data, and message is the data
+ * which was received.
+ * 
+ * The argument write_callback is the name of a function for the driver to
+ * call  when  the  socket  is  ready to be written to. The write callback
+ * should follow this format:
+ * 
+ * void write_callback(int fd)
+ * 
+ * Where fd is the socket which is ready to be written to.
+ *
+ */
+
+
+int socket_connect( int s, string address,
+                    string read_callback,
+                    string write_callback );
+
+/**
+ * socket_close() - close a socket
+ *
+ * socket_close() closes socket s. This frees a socket efun slot for use.
+ *
+ */
+
+
+int socket_close( int s );
+
+/**
+ * socket_bind() - bind a name to a socket
+ *
+ * socket_bind()  assigns  a  name  to an unnamed socket. When a socket is
+ * created with socket_create(3) it exists in a name space  (address  fam‐
+ * ily)  but has no name assigned. socket_bind() requests that the port be
+ * assigned to the socket s.
+ *
+ */
+
+
+int socket_bind( int s, int port );
+
+/**
+ * socket_address() - return the remote address for an efun socket
+ *
+ * socket_address()  returns the remote address for an efun socket s.  The
+ * returned address is of the form:
+ * 
+ * "127.0.0.1 23".
+ *
+ */
+
+
+string socket_address( int s );
+
+/**
+ * socket_acquire() - assume ownership of a socket
+ *
+ * socket_acquire()   is   called  to  complete  the  handshake  begun  by
+ * socket_release() for transferring ownership (and control) of  a  socket
+ * to  a new object.  socket_release() calls the release callback function
+ * within the new owner object to notify the object that it wishes to pass
+ * control  of  the  socket on.  It is the responsibility of the new owner
+ * socket to decide whether it wishes to accept the socket.  It  it  does,
+ * then socket_acquire() is called to complete the transfer.  If not, then
+ * the callback simply returns without completing the handshake.
+ * 
+ * In the former case the  handshake  is  completed  and  the  new  object
+ * becomes  the socket owner.  The read, write and close callback function
+ * parameters refer to functions within the new object.  These are  speci‐
+ * fied  so that the MudOS driver will know which functions to call within
+ * the  new  object.   Decling  to   acquire   the   socket   will   cause
+ * socket_release()  to  return  EESOCKNOTRLSD  so  the  owner can perform
+ * appropriate clean-up.
+ * 
+ * socket_acquire() may only be called within the context of  thr  release
+ * callback function and only with the socket specified.
+ *
+ */
+
+
+int socket_acquire( int socket, string read_callback,
+                    string write_callback,
+                    string close_callback );
+
+/**
+ * socket_accept() - accept a connection on a socket
+ *
+ * The argument s is a socket that has been created with socket_create(3),
+ * bound to an address with socket_bind(3), and is listening  for  connec‐
+ * tions after a socket_listen(3). socket_accept() extracts the first con‐
+ * nection on the queue of pending connections, creates a new socket  with
+ * the  same  properties  of s and allocates a new file descriptor for the
+ * socket.  If  no  pending  connections  are  present   on   the   queue,
+ * socket_accept()  returns  an  error  as  described  below. The accepted
+ * socket is used to read and write data to and from the socket which con‐
+ * nected  to  this  one;  it  is not used to accept more connections. The
+ * original socket s remains open for accepting further connections.
+ * 
+ * The argument read_callback is the name of a function for the driver  to
+ * call when the new socket (not the accepting socket) receives data.  The
+ * write callback should follow this format:
+ * 
+ * void read_callback(int fd)
+ * 
+ * Where fd is the socket which is ready to accept data.
+ * 
+ * The argument write_callback is the name of a function for the driver to
+ * call  when  the  new  socket  (not the accepting socket) is ready to be
+ * written to. The write callback should follow this format:
+ * 
+ * void write_callback(int fd)
+ * 
+ * Where fd is the socket which is ready to be written to.
+ * 
+ * Note: The close_callback of the accepting socket (not the  new  socket)
+ * is called if the new socket closes unexpectedly, i.e. not as the result
+ * of a socket_close(3) call. The close callback should follow  this  for‐
+ * mat:
+ * 
+ * void close_callback(int fd)
+ * 
+ * Where fd is the socket which has closed.
+ *
+ */
+
+
+int socket_accept( int s, string read_callback,
+                   string write_callback );
+
+
+/**
+ * Set the option for a socket.
+ * @param socket 
+ * @param option 
+ * @param host 
+ */
+void socket_set_option(int socket, int option, int|string host);