.
If that also fails,
it tries an all-in-one loader (see package.loaders
).
Once a loader is found,
require
calls the loader with a single argument, modname
.
If the loader returns any value,
require
assigns the returned value to package.loaded[modname]
.
If the loader returns no value and
has not assigned any value to package.loaded[modname]
,
then require
assigns true to this entry.
In any case, require
returns the
final value of package.loaded[modname]
.
If there is any error loading or running the module,
or if it cannot find any loader for the module,
then require
signals an error.
package.cpath
The path used by require
to search for a C loader.
Lua initializes the C path package.cpath
in the same way
it initializes the Lua path package.path
,
using the environment variable LUA_CPATH
or a default path defined in luaconf.h
.
package.loaded
A table used by require
to control which
modules are already loaded.
When you require a module modname
and
package.loaded[modname]
is not false,
require
simply returns the value stored there.
package.loaders
A table used by require
to control how to load modules.
Each entry in this table is a searcher function.
When looking for a module,
require
calls each of these searchers in ascending order,
with the module name (the argument given to require
) as its
sole parameter.
The function can return another function (the module loader)
or a string explaining why it did not find that module
(or nil if it has nothing to say).
Lua initializes this table with four functions.
The first searcher simply looks for a loader in the
package.preload
table.
The second searcher looks for a loader as a Lua library,
using the path stored at package.path
.
A path is a sequence of templates separated by semicolons.
For each template,
the searcher will change each interrogation
mark in the template by filename
,
which is the module name with each dot replaced by a
"directory separator" (such as "/
" in Unix);
then it will try to open the resulting file name.
So, for instance, if the Lua path is the string
"./?.lua;./?.lc;/usr/local/?/init.lua"
the search for a Lua file for module foo
will try to open the files
./foo.lua
, ./foo.lc
, and
/usr/local/foo/init.lua
, in that order.
The third searcher looks for a loader as a C library,
using the path given by the variable package.cpath
.
For instance,
if the C path is the string
"./?.so;./?.dll;/usr/local/?/init.so"
the searcher for module foo
will try to open the files ./foo.so
, ./foo.dll
,
and /usr/local/foo/init.so
, in that order.
Once it finds a C library,
this searcher first uses a dynamic link facility to link the
application with the library.
Then it tries to find a C function inside the library to
be used as the loader.
The name of this C function is the string "luaopen_
"
concatenated with a copy of the module name where each dot
is replaced by an underscore.
Moreover, if the module name has a hyphen,
its prefix up to (and including) the first hyphen is removed.
For instance, if the module name is a.v1-b.c
,
the function name will be luaopen_b_c
.
The fourth searcher tries an all-in-one loader.
It searches the C path for a library for
the root name of the given module.
For instance, when requiring a.b.c
,
it will search for a C library for a
.
If found, it looks into it for an open function for
the submodule;
in our example, that would be luaopen_a_b_c
.
With this facility, a package can pack several C submodules
into one single library,
with each submodule keeping its original open function.
package.loadlib (libname, funcname)
Dynamically links the host program with the C library libname
.
Inside this library, looks for a function funcname
and returns this function as a C function.
(So, funcname
must follow the protocol (see lua_CFunction
)).
This is a low-level function.
It completely bypasses the package and module system.
Unlike require
,
it does not perform any path searching and
does not automatically adds extensions.
libname
must be the complete file name of the C library,
including if necessary a path and extension.
funcname
must be the exact name exported by the C library
(which may depend on the C compiler and linker used).
This function is not supported by ANSI C.
As such, it is only available on some platforms
(Windows, Linux, Mac OS X, Solaris, BSD,
plus other Unix systems that support the dlfcn
standard).
package.path
The path used by require
to search for a Lua loader.
At start-up, Lua initializes this variable with
the value of the environment variable LUA_PATH
or
with a default path defined in luaconf.h
,
if the environment variable is not defined.
Any ";;
" in the value of the environment variable
is replaced by the default path.
package.preload
A table to store loaders for specific modules
(see require
).
package.seeall (module)
Sets a metatable for module
with
its __index
field referring to the global environment,
so that this module inherits values
from the global environment.
To be used as an option to function module
.
This library provides generic functions for string manipulation, such as finding and extracting substrings, and pattern matching. When indexing a string in Lua, the first character is at position 1 (not at 0, as in C). Indices are allowed to be negative and are interpreted as indexing backwards, from the end of the string. Thus, the last character is at position -1, and so on.
The string library provides all its functions inside the table
string
.
It also sets a metatable for strings
where the __index
field points to the string
table.
Therefore, you can use the string functions in object-oriented style.
For instance, string.byte(s, i)
can be written as s:byte(i)
.
The string library assumes one-byte character encodings.
string.byte (s [, i [, j]])
s[i]
,
s[i+1]
, ···, s[j]
.
The default value for i
is 1;
the default value for j
is i
.
Note that numerical codes are not necessarily portable across platforms.
string.char (···)
Note that numerical codes are not necessarily portable across platforms.
string.dump (function)
Returns a string containing a binary representation of the given function,
so that a later loadstring
on this string returns
a copy of the function.
function
must be a Lua function without upvalues.
string.find (s, pattern [, init [, plain]])
pattern
in the string s
.
If it finds a match, then find
returns the indices of s
where this occurrence starts and ends;
otherwise, it returns nil.
A third, optional numerical argument init
specifies
where to start the search;
its default value is 1 and can be negative.
A value of true as a fourth, optional argument plain
turns off the pattern matching facilities,
so the function does a plain "find substring" operation,
with no characters in pattern
being considered "magic".
Note that if plain
is given, then init
must be given as well.
If the pattern has captures, then in a successful match the captured values are also returned, after the two indices.
string.format (formatstring, ···)
printf
family of
standard C functions.
The only differences are that the options/modifiers
*
, l
, L
, n
, p
,
and h
are not supported
and that there is an extra option, q
.
The q
option formats a string in a form suitable to be safely read
back by the Lua interpreter:
the string is written between double quotes,
and all double quotes, newlines, embedded zeros,
and backslashes in the string
are correctly escaped when written.
For instance, the call
string.format('%q', 'a string with "quotes" and \n new line')
will produce the string:
"a string with \"quotes\" and \ new line"
The options c
, d
, E
, e
, f
,
g
, G
, i
, o
, u
, X
, and x
all
expect a number as argument,
whereas q
and s
expect a string.
This function does not accept string values
containing embedded zeros,
except as arguments to the q
option.
string.gmatch (s, pattern)
pattern
over string s
.
If pattern
specifies no captures,
then the whole match is produced in each call.
As an example, the following loop
s = "hello world from Lua" for w in string.gmatch(s, "%a+") do print(w) end
will iterate over all the words from string s
,
printing one per line.
The next example collects all pairs key=value
from the
given string into a table:
t = {} s = "from=world, to=Lua" for k, v in string.gmatch(s, "(%w+)=(%w+)") do t[k] = v end
For this function, a '^
' at the start of a pattern does not
work as an anchor, as this would prevent the iteration.
string.gsub (s, pattern, repl [, n])
s
in which all (or the first n
, if given)
occurrences of the pattern
have been
replaced by a replacement string specified by repl
,
which can be a string, a table, or a function.
gsub
also returns, as its second value,
the total number of matches that occurred.
If repl
is a string, then its value is used for replacement.
The character %
works as an escape character:
any sequence in repl
of the form %n
,
with n between 1 and 9,
stands for the value of the n-th captured substring (see below).
The sequence %0
stands for the whole match.
The sequence %%
stands for a single %
.
If repl
is a table, then the table is queried for every match,
using the first capture as the key;
if the pattern specifies no captures,
then the whole match is used as the key.
If repl
is a function, then this function is called every time a
match occurs, with all captured substrings passed as arguments,
in order;
if the pattern specifies no captures,
then the whole match is passed as a sole argument.
If the value returned by the table query or by the function call is a string or a number, then it is used as the replacement string; otherwise, if it is false or nil, then there is no replacement (that is, the original match is kept in the string).
Here are some examples:
x = string.gsub("hello world", "(%w+)", "%1 %1") --> x="hello hello world world" x = string.gsub("hello world", "%w+", "%0 %0", 1) --> x="hello hello world" x = string.gsub("hello world from Lua", "(%w+)%s*(%w+)", "%2 %1") --> x="world hello Lua from" x = string.gsub("home = $HOME, user = $USER", "%$(%w+)", os.getenv) --> x="home = /home/roberto, user = roberto" x = string.gsub("4+5 = $return 4+5$", "%$(.-)%$", function (s) return loadstring(s)() end) --> x="4+5 = 9" local t = {name="lua", version="5.1"} x = string.gsub("$name-$version.tar.gz", "%$(%w+)", t) --> x="lua-5.1.tar.gz"
string.len (s)
""
has length 0.
Embedded zeros are counted,
so "a\000bc\000"
has length 5.
string.lower (s)
string.match (s, pattern [, init])
pattern
in the string s
.
If it finds one, then match
returns
the captures from the pattern;
otherwise it returns nil.
If pattern
specifies no captures,
then the whole match is returned.
A third, optional numerical argument init
specifies
where to start the search;
its default value is 1 and can be negative.
string.rep (s, n)
n
copies of
the string s
.
string.reverse (s)
s
reversed.
string.sub (s, i [, j])
s
that
starts at i
and continues until j
;
i
and j
can be negative.
If j
is absent, then it is assumed to be equal to -1
(which is the same as the string length).
In particular,
the call string.sub(s,1,j)
returns a prefix of s
with length j
,
and string.sub(s, -i)
returns a suffix of s
with length i
.
string.upper (s)
A character class is used to represent a set of characters. The following combinations are allowed in describing a character class:
^$()%.[]*+-?
)
represents the character x itself.
.
: (a dot) represents all characters.%a
: represents all letters.%c
: represents all control characters.%d
: represents all digits.%l
: represents all lowercase letters.%p
: represents all punctuation characters.%s
: represents all space characters.%u
: represents all uppercase letters.%w
: represents all alphanumeric characters.%x
: represents all hexadecimal digits.%z
: represents the character with representation 0.%x
: (where x is any non-alphanumeric character)
represents the character x.
This is the standard way to escape the magic characters.
Any punctuation character (even the non magic)
can be preceded by a '%
'
when used to represent itself in a pattern.
[set]
:
represents the class which is the union of all
characters in set.
A range of characters can be specified by
separating the end characters of the range with a '-
'.
All classes %
x described above can also be used as
components in set.
All other characters in set represent themselves.
For example, [%w_]
(or [_%w]
)
represents all alphanumeric characters plus the underscore,
[0-7]
represents the octal digits,
and [0-7%l%-]
represents the octal digits plus
the lowercase letters plus the '-
' character.
The interaction between ranges and classes is not defined.
Therefore, patterns like [%a-z]
or [a-%%]
have no meaning.
[^set]
:
represents the complement of set,
where set is interpreted as above.
For all classes represented by single letters (%a
, %c
, etc.),
the corresponding uppercase letter represents the complement of the class.
For instance, %S
represents all non-space characters.
The definitions of letter, space, and other character groups
depend on the current locale.
In particular, the class [a-z]
may not be equivalent to %l
.
A pattern item can be
*
',
which matches 0 or more repetitions of characters in the class.
These repetition items will always match the longest possible sequence;
+
',
which matches 1 or more repetitions of characters in the class.
These repetition items will always match the longest possible sequence;
-
',
which also matches 0 or more repetitions of characters in the class.
Unlike '*
',
these repetition items will always match the shortest possible sequence;
?
',
which matches 0 or 1 occurrence of a character in the class;
%n
, for n between 1 and 9;
such item matches a substring equal to the n-th captured string
(see below);
%bxy
, where x and y are two distinct characters;
such item matches strings that start with x, end with y,
and where the x and y are balanced.
This means that, if one reads the string from left to right,
counting +1 for an x and -1 for a y,
the ending y is the first y where the count reaches 0.
For instance, the item %b()
matches expressions with
balanced parentheses.
A pattern is a sequence of pattern items.
A '^
' at the beginning of a pattern anchors the match at the
beginning of the subject string.
A '$
' at the end of a pattern anchors the match at the
end of the subject string.
At other positions,
'^
' and '$
' have no special meaning and represent themselves.
A pattern can contain sub-patterns enclosed in parentheses;
they describe captures.
When a match succeeds, the substrings of the subject string
that match captures are stored (captured) for future use.
Captures are numbered according to their left parentheses.
For instance, in the pattern "(a*(.)%w(%s*))"
,
the part of the string matching "a*(.)%w(%s*)"
is
stored as the first capture (and therefore has number 1);
the character matching ".
" is captured with number 2,
and the part matching "%s*
" has number 3.
As a special case, the empty capture ()
captures
the current string position (a number).
For instance, if we apply the pattern "()aa()"
on the
string "flaaap"
, there will be two captures: 3 and 5.
A pattern cannot contain embedded zeros. Use %z
instead.
This library provides generic functions for table manipulation.
It provides all its functions inside the table table
.
Most functions in the table library assume that the table represents an array or a list. For these functions, when we talk about the "length" of a table we mean the result of the length operator.
table.concat (table [, sep [, i [, j]]])
table[i]..sep..table[i+1] ··· sep..table[j]
.
The default value for sep
is the empty string,
the default for i
is 1,
and the default for j
is the length of the table.
If i
is greater than j
, returns the empty string.
table.insert (table, [pos,] value)
Inserts element value
at position pos
in table
,
shifting up other elements to open space, if necessary.
The default value for pos
is n+1
,
where n
is the length of the table (see §2.5.5),
so that a call table.insert(t,x)
inserts x
at the end
of table t
.
table.maxn (table)
Returns the largest positive numerical index of the given table, or zero if the table has no positive numerical indices. (To do its job this function does a linear traversal of the whole table.)
table.remove (table [, pos])
Removes from table
the element at position pos
,
shifting down other elements to close the space, if necessary.
Returns the value of the removed element.
The default value for pos
is n
,
where n
is the length of the table,
so that a call table.remove(t)
removes the last element
of table t
.
table.sort (table [, comp])
table[1]
to table[n]
,
where n
is the length of the table.
If comp
is given,
then it must be a function that receives two table elements,
and returns true
when the first is less than the second
(so that not comp(a[i+1],a[i])
will be true after the sort).
If comp
is not given,
then the standard Lua operator <
is used instead.
The sort algorithm is not stable; that is, elements considered equal by the given order may have their relative positions changed by the sort.
This library is an interface to the standard C math library.
It provides all its functions inside the table math
.
math.abs (x)
Returns the absolute value of x
.
math.acos (x)
Returns the arc cosine of x
(in radians).
math.asin (x)
Returns the arc sine of x
(in radians).
math.atan (x)
Returns the arc tangent of x
(in radians).
math.atan2 (y, x)
Returns the arc tangent of y/x
(in radians),
but uses the signs of both parameters to find the
quadrant of the result.
(It also handles correctly the case of x
being zero.)
math.ceil (x)
Returns the smallest integer larger than or equal to x
.
math.cos (x)
Returns the cosine of x
(assumed to be in radians).
math.cosh (x)
Returns the hyperbolic cosine of x
.
math.deg (x)
Returns the angle x
(given in radians) in degrees.
math.exp (x)
Returns the value ex.
math.floor (x)
Returns the largest integer smaller than or equal to x
.
math.fmod (x, y)
Returns the remainder of the division of x
by y
that rounds the quotient towards zero.
math.frexp (x)
Returns m
and e
such that x = m2e,
e
is an integer and the absolute value of m
is
in the range [0.5, 1)
(or zero when x
is zero).
math.huge
The value HUGE_VAL
,
a value larger than or equal to any other numerical value.
math.ldexp (m, e)
Returns m2e (e
should be an integer).
math.log (x)
Returns the natural logarithm of x
.
math.log10 (x)
Returns the base-10 logarithm of x
.
math.max (x, ···)
Returns the maximum value among its arguments.
math.min (x, ···)
Returns the minimum value among its arguments.
math.modf (x)
Returns two numbers,
the integral part of x
and the fractional part of x
.
math.pi
The value of pi.
math.pow (x, y)
Returns xy.
(You can also use the expression x^y
to compute this value.)
math.rad (x)
Returns the angle x
(given in degrees) in radians.
math.random ([m [, n]])
This function is an interface to the simple
pseudo-random generator function rand
provided by ANSI C.
(No guarantees can be given for its statistical properties.)
When called without arguments,
returns a uniform pseudo-random real number
in the range [0,1).
When called with an integer number m
,
math.random
returns
a uniform pseudo-random integer in the range [1, m].
When called with two integer numbers m
and n
,
math.random
returns a uniform pseudo-random
integer in the range [m, n].
math.randomseed (x)
Sets x
as the "seed"
for the pseudo-random generator:
equal seeds produce equal sequences of numbers.
math.sin (x)
Returns the sine of x
(assumed to be in radians).
math.sinh (x)
Returns the hyperbolic sine of x
.
math.sqrt (x)
Returns the square root of x
.
(You can also use the expression x^0.5
to compute this value.)
math.tan (x)
Returns the tangent of x
(assumed to be in radians).
math.tanh (x)
Returns the hyperbolic tangent of x
.
The I/O library provides two different styles for file manipulation. The first one uses implicit file descriptors; that is, there are operations to set a default input file and a default output file, and all input/output operations are over these default files. The second style uses explicit file descriptors.
When using implicit file descriptors,
all operations are supplied by table io
.
When using explicit file descriptors,
the operation io.open
returns a file descriptor
and then all operations are supplied as methods of the file descriptor.
The table io
also provides
three predefined file descriptors with their usual meanings from C:
io.stdin
, io.stdout
, and io.stderr
.
The I/O library never closes these files.
Unless otherwise stated, all I/O functions return nil on failure (plus an error message as a second result and a system-dependent error code as a third result) and some value different from nil on success.
io.close ([file])
Equivalent to file:close()
.
Without a file
, closes the default output file.
io.flush ()
Equivalent to file:flush
over the default output file.
io.input ([file])
When called with a file name, it opens the named file (in text mode), and sets its handle as the default input file. When called with a file handle, it simply sets this file handle as the default input file. When called without parameters, it returns the current default input file.
In case of errors this function raises the error, instead of returning an error code.
io.lines ([filename])
Opens the given file name in read mode and returns an iterator function that, each time it is called, returns a new line from the file. Therefore, the construction
for line in io.lines(filename) do body end
will iterate over all lines of the file. When the iterator function detects the end of file, it returns nil (to finish the loop) and automatically closes the file.
The call io.lines()
(with no file name) is equivalent
to io.input():lines()
;
that is, it iterates over the lines of the default input file.
In this case it does not close the file when the loop ends.
io.open (filename [, mode])
This function opens a file,
in the mode specified in the string mode
.
It returns a new file handle,
or, in case of errors, nil plus an error message.
The mode
string can be any of the following:
The mode
string can also have a 'b
' at the end,
which is needed in some systems to open the file in binary mode.
This string is exactly what is used in the
standard C function fopen
.
io.output ([file])
Similar to io.input
, but operates over the default output file.
io.popen (prog [, mode])
Starts program prog
in a separated process and returns
a file handle that you can use to read data from this program
(if mode
is "r"
, the default)
or to write data to this program
(if mode
is "w"
).
This function is system dependent and is not available on all platforms.
io.read (···)
Equivalent to io.input():read
.
io.tmpfile ()
Returns a handle for a temporary file. This file is opened in update mode and it is automatically removed when the program ends.
io.type (obj)
Checks whether obj
is a valid file handle.
Returns the string "file"
if obj
is an open file handle,
"closed file"
if obj
is a closed file handle,
or nil if obj
is not a file handle.
io.write (···)
Equivalent to io.output():write
.
file:close ()
Closes file
.
Note that files are automatically closed when
their handles are garbage collected,
but that takes an unpredictable amount of time to happen.
file:flush ()
Saves any written data to file
.
file:lines ()
Returns an iterator function that, each time it is called, returns a new line from the file. Therefore, the construction
for line in file:lines() do body end
will iterate over all lines of the file.
(Unlike io.lines
, this function does not close the file
when the loop ends.)
file:read (···)
Reads the file file
,
according to the given formats, which specify what to read.
For each format,
the function returns a string (or a number) with the characters read,
or nil if it cannot read data with the specified format.
When called without formats,
it uses a default format that reads the entire next line
(see below).
The available formats are
file:seek ([whence] [, offset])
Sets and gets the file position,
measured from the beginning of the file,
to the position given by offset
plus a base
specified by the string whence
, as follows:
In case of success, function seek
returns the final file position,
measured in bytes from the beginning of the file.
If this function fails, it returns nil,
plus a string describing the error.
The default value for whence
is "cur"
,
and for offset
is 0.
Therefore, the call file:seek()
returns the current
file position, without changing it;
the call file:seek("set")
sets the position to the
beginning of the file (and returns 0);
and the call file:seek("end")
sets the position to the
end of the file, and returns its size.
file:setvbuf (mode [, size])
Sets the buffering mode for an output file. There are three available modes:
flush
the file
(see io.flush
)).
For the last two cases, size
specifies the size of the buffer, in bytes.
The default is an appropriate size.
file:write (···)
Writes the value of each of its arguments to
the file
.
The arguments must be strings or numbers.
To write other values,
use tostring
or string.format
before write
.
This library is implemented through table os
.
os.clock ()
Returns an approximation of the amount in seconds of CPU time used by the program.
os.date ([format [, time]])
Returns a string or a table containing date and time,
formatted according to the given string format
.
If the time
argument is present,
this is the time to be formatted
(see the os.time
function for a description of this value).
Otherwise, date
formats the current time.
If format
starts with '!
',
then the date is formatted in Coordinated Universal Time.
After this optional character,
if format
is the string "*t
",
then date
returns a table with the following fields:
year
(four digits), month
(1--12), day
(1--31),
hour
(0--23), min
(0--59), sec
(0--61),
wday
(weekday, Sunday is 1),
yday
(day of the year),
and isdst
(daylight saving flag, a boolean).
If format
is not "*t
",
then date
returns the date as a string,
formatted according to the same rules as the C function strftime
.
When called without arguments,
date
returns a reasonable date and time representation that depends on
the host system and on the current locale
(that is, os.date()
is equivalent to os.date("%c")
).
os.difftime (t2, t1)
Returns the number of seconds from time t1
to time t2
.
In POSIX, Windows, and some other systems,
this value is exactly t2
-t1
.
os.execute ([command])
This function is equivalent to the C function system
.
It passes command
to be executed by an operating system shell.
It returns a status code, which is system-dependent.
If command
is absent, then it returns nonzero if a shell is available
and zero otherwise.
os.exit ([code])
Calls the C function exit
,
with an optional code
,
to terminate the host program.
The default value for code
is the success code.
os.getenv (varname)
Returns the value of the process environment variable varname
,
or nil if the variable is not defined.
os.remove (filename)
Deletes the file or directory with the given name. Directories must be empty to be removed. If this function fails, it returns nil, plus a string describing the error.
os.rename (oldname, newname)
Renames file or directory named oldname
to newname
.
If this function fails, it returns nil,
plus a string describing the error.
os.setlocale (locale [, category])
Sets the current locale of the program.
locale
is a string specifying a locale;
category
is an optional string describing which category to change:
"all"
, "collate"
, "ctype"
,
"monetary"
, "numeric"
, or "time"
;
the default category is "all"
.
The function returns the name of the new locale,
or nil if the request cannot be honored.
If locale
is the empty string,
the current locale is set to an implementation-defined native locale.
If locale
is the string "C
",
the current locale is set to the standard C locale.
When called with nil as the first argument, this function only returns the name of the current locale for the given category.
os.time ([table])
Returns the current time when called without arguments,
or a time representing the date and time specified by the given table.
This table must have fields year
, month
, and day
,
and may have fields hour
, min
, sec
, and isdst
(for a description of these fields, see the os.date
function).
The returned value is a number, whose meaning depends on your system.
In POSIX, Windows, and some other systems, this number counts the number
of seconds since some given start time (the "epoch").
In other systems, the meaning is not specified,
and the number returned by time
can be used only as an argument to
date
and difftime
.
os.tmpname ()
Returns a string with a file name that can be used for a temporary file. The file must be explicitly opened before its use and explicitly removed when no longer needed.
On some systems (POSIX), this function also creates a file with that name, to avoid security risks. (Someone else might create the file with wrong permissions in the time between getting the name and creating the file.) You still have to open the file to use it and to remove it (even if you do not use it).
When possible,
you may prefer to use io.tmpfile
,
which automatically removes the file when the program ends.
This library provides the functionality of the debug interface to Lua programs. You should exert care when using this library. The functions provided here should be used exclusively for debugging and similar tasks, such as profiling. Please resist the temptation to use them as a usual programming tool: they can be very slow. Moreover, several of these functions violate some assumptions about Lua code (e.g., that variables local to a function cannot be accessed from outside or that userdata metatables cannot be changed by Lua code) and therefore can compromise otherwise secure code.
All functions in this library are provided
inside the debug
table.
All functions that operate over a thread
have an optional first argument which is the
thread to operate over.
The default is always the current thread.
debug.debug ()
Enters an interactive mode with the user,
running each string that the user enters.
Using simple commands and other debug facilities,
the user can inspect global and local variables,
change their values, evaluate expressions, and so on.
A line containing only the word cont
finishes this function,
so that the caller continues its execution.
Note that commands for debug.debug
are not lexically nested
within any function, and so have no direct access to local variables.
debug.getfenv (o)
o
.
debug.gethook ([thread])
Returns the current hook settings of the thread, as three values:
the current hook function, the current hook mask,
and the current hook count
(as set by the debug.sethook
function).
debug.getinfo ([thread,] function [, what])
Returns a table with information about a function.
You can give the function directly,
or you can give a number as the value of function
,
which means the function running at level function
of the call stack
of the given thread:
level 0 is the current function (getinfo
itself);
level 1 is the function that called getinfo
;
and so on.
If function
is a number larger than the number of active functions,
then getinfo
returns nil.
The returned table can contain all the fields returned by lua_getinfo
,
with the string what
describing which fields to fill in.
The default for what
is to get all information available,
except the table of valid lines.
If present,
the option 'f
'
adds a field named func
with the function itself.
If present,
the option 'L
'
adds a field named activelines
with the table of
valid lines.
For instance, the expression debug.getinfo(1,"n").name
returns
a table with a name for the current function,
if a reasonable name can be found,
and the expression debug.getinfo(print)
returns a table with all available information
about the print
function.
debug.getlocal ([thread,] level, local)
This function returns the name and the value of the local variable
with index local
of the function at level level
of the stack.
(The first parameter or local variable has index 1, and so on,
until the last active local variable.)
The function returns nil if there is no local
variable with the given index,
and raises an error when called with a level
out of range.
(You can call debug.getinfo
to check whether the level is valid.)
Variable names starting with '(
' (open parentheses)
represent internal variables
(loop control variables, temporaries, and C function locals).
debug.getmetatable (object)
Returns the metatable of the given object
or nil if it does not have a metatable.
debug.getregistry ()
Returns the registry table (see §3.5).
debug.getupvalue (func, up)
This function returns the name and the value of the upvalue
with index up
of the function func
.
The function returns nil if there is no upvalue with the given index.
debug.setfenv (object, table)
Sets the environment of the given object
to the given table
.
Returns object
.
debug.sethook ([thread,] hook, mask [, count])
Sets the given function as a hook.
The string mask
and the number count
describe
when the hook will be called.
The string mask may have the following characters,
with the given meaning:
"c"
: the hook is called every time Lua calls a function;"r"
: the hook is called every time Lua returns from a function;"l"
: the hook is called every time Lua enters a new line of code.
With a count
different from zero,
the hook is called after every count
instructions.
When called without arguments,
debug.sethook
turns off the hook.
When the hook is called, its first parameter is a string
describing the event that has triggered its call:
"call"
, "return"
(or "tail return"
,
when simulating a return from a tail call),
"line"
, and "count"
.
For line events,
the hook also gets the new line number as its second parameter.
Inside a hook,
you can call getinfo
with level 2 to get more information about
the running function
(level 0 is the getinfo
function,
and level 1 is the hook function),
unless the event is "tail return"
.
In this case, Lua is only simulating the return,
and a call to getinfo
will return invalid data.
debug.setlocal ([thread,] level, local, value)
This function assigns the value value
to the local variable
with index local
of the function at level level
of the stack.
The function returns nil if there is no local
variable with the given index,
and raises an error when called with a level
out of range.
(You can call getinfo
to check whether the level is valid.)
Otherwise, it returns the name of the local variable.
debug.setmetatable (object, table)
Sets the metatable for the given object
to the given table
(which can be nil).
debug.setupvalue (func, up, value)
This function assigns the value value
to the upvalue
with index up
of the function func
.
The function returns nil if there is no upvalue
with the given index.
Otherwise, it returns the name of the upvalue.
debug.traceback ([thread,] [message [, level]])
Returns a string with a traceback of the call stack.
An optional message
string is appended
at the beginning of the traceback.
An optional level
number tells at which level
to start the traceback
(default is 1, the function calling traceback
).
Although Lua has been designed as an extension language,
to be embedded in a host C program,
it is also frequently used as a stand-alone language.
An interpreter for Lua as a stand-alone language,
called simply lua
,
is provided with the standard distribution.
The stand-alone interpreter includes
all standard libraries, including the debug library.
Its usage is:
lua [options] [script [args]]
The options are:
-e stat
: executes string stat;-l mod
: "requires" mod;-i
: enters interactive mode after running script;-v
: prints version information;--
: stops handling options;-
: executes stdin
as a file and stops handling options.
After handling its options, lua
runs the given script,
passing to it the given args as string arguments.
When called without arguments,
lua
behaves as lua -v -i
when the standard input (stdin
) is a terminal,
and as lua -
otherwise.
Before running any argument,
the interpreter checks for an environment variable LUA_INIT
.
If its format is @filename
,
then lua
executes the file.
Otherwise, lua
executes the string itself.
All options are handled in order, except -i
.
For instance, an invocation like
$ lua -e'a=1' -e 'print(a)' script.lua
will first set a
to 1, then print the value of a
(which is '1
'),
and finally run the file script.lua
with no arguments.
(Here $
is the shell prompt. Your prompt may be different.)
Before starting to run the script,
lua
collects all arguments in the command line
in a global table called arg
.
The script name is stored at index 0,
the first argument after the script name goes to index 1,
and so on.
Any arguments before the script name
(that is, the interpreter name plus the options)
go to negative indices.
For instance, in the call
$ lua -la b.lua t1 t2
the interpreter first runs the file a.lua
,
then creates a table
arg = { [-2] = "lua", [-1] = "-la", [0] = "b.lua", [1] = "t1", [2] = "t2" }
and finally runs the file b.lua
.
The script is called with arg[1]
, arg[2]
, ···
as arguments;
it can also access these arguments with the vararg expression '...
'.
In interactive mode, if you write an incomplete statement, the interpreter waits for its completion by issuing a different prompt.
If the global variable _PROMPT
contains a string,
then its value is used as the prompt.
Similarly, if the global variable _PROMPT2
contains a string,
its value is used as the secondary prompt
(issued during incomplete statements).
Therefore, both prompts can be changed directly on the command line
or in any Lua programs by assigning to _PROMPT
.
See the next example:
$ lua -e"_PROMPT='myprompt> '" -i
(The outer pair of quotes is for the shell,
the inner pair is for Lua.)
Note the use of -i
to enter interactive mode;
otherwise,
the program would just end silently
right after the assignment to _PROMPT
.
To allow the use of Lua as a
script interpreter in Unix systems,
the stand-alone interpreter skips
the first line of a chunk if it starts with #
.
Therefore, Lua scripts can be made into executable programs
by using chmod +x
and the #!
form,
as in
#!/usr/local/bin/lua
(Of course,
the location of the Lua interpreter may be different in your machine.
If lua
is in your PATH
,
then
#!/usr/bin/env lua
is a more portable solution.)
Here we list the incompatibilities that you may find when moving a program
from Lua 5.0 to Lua 5.1.
You can avoid most of the incompatibilities compiling Lua with
appropriate options (see file luaconf.h
).
However,
all these compatibility options will be removed in the next version of Lua.
arg
with a
table with the extra arguments to the vararg expression.
(See compile-time option LUA_COMPAT_VARARG
in luaconf.h
.)
[[string]]
)
does not allow nesting.
You can use the new syntax ([=[string]=]
) in these cases.
(See compile-time option LUA_COMPAT_LSTR
in luaconf.h
.)
string.gfind
was renamed string.gmatch
.
(See compile-time option LUA_COMPAT_GFIND
in luaconf.h
.)
string.gsub
is called with a function as its
third argument,
whenever this function returns nil or false the
replacement string is the whole match,
instead of the empty string.
table.setn
was deprecated.
Function table.getn
corresponds
to the new length operator (#
);
use the operator instead of the function.
(See compile-time option LUA_COMPAT_GETN
in luaconf.h
.)
loadlib
was renamed package.loadlib
.
(See compile-time option LUA_COMPAT_LOADLIB
in luaconf.h
.)
math.mod
was renamed math.fmod
.
(See compile-time option LUA_COMPAT_MOD
in luaconf.h
.)
table.foreach
and table.foreachi
are deprecated.
You can use a for loop with pairs
or ipairs
instead.
require
due to
the new module system.
However, the new behavior is mostly compatible with the old,
but require
gets the path from package.path
instead
of from LUA_PATH
.
collectgarbage
has different arguments.
Function gcinfo
is deprecated;
use collectgarbage("count")
instead.
luaopen_*
functions (to open libraries)
cannot be called directly,
like a regular C function.
They must be called through Lua,
like a Lua function.
lua_open
was replaced by lua_newstate
to
allow the user to set a memory-allocation function.
You can use luaL_newstate
from the standard library to
create a state with a standard allocation function
(based on realloc
).
luaL_getn
and luaL_setn
(from the auxiliary library) are deprecated.
Use lua_objlen
instead of luaL_getn
and nothing instead of luaL_setn
.
luaL_openlib
was replaced by luaL_register
.
luaL_checkudata
now throws an error when the given value
is not a userdata of the expected type.
(In Lua 5.0 it returned NULL
.)
Here is the complete syntax of Lua in extended BNF. (It does not describe operator precedences.)
chunk ::= {stat [`;´]} [laststat [`;´]] block ::= chunk stat ::= varlist `=´ explist | functioncall | do block end | while exp do block end | repeat block until exp | if exp then block {elseif exp then block} [else block] end | for Name `=´ exp `,´ exp [`,´ exp] do block end | for namelist in explist do block end | function funcname funcbody | local function Name funcbody | local namelist [`=´ explist] laststat ::= return [explist] | break funcname ::= Name {`.´ Name} [`:´ Name] varlist ::= var {`,´ var} var ::= Name | prefixexp `[´ exp `]´ | prefixexp `.´ Name namelist ::= Name {`,´ Name} explist ::= {exp `,´} exp exp ::= nil | false | true | Number | String | `...´ | function | prefixexp | tableconstructor | exp binop exp | unop exp prefixexp ::= var | functioncall | `(´ exp `)´ functioncall ::= prefixexp args | prefixexp `:´ Name args args ::= `(´ [explist] `)´ | tableconstructor | String function ::= function funcbody funcbody ::= `(´ [parlist] `)´ block end parlist ::= namelist [`,´ `...´] | `...´ tableconstructor ::= `{´ [fieldlist] `}´ fieldlist ::= field {fieldsep field} [fieldsep] field ::= `[´ exp `]´ `=´ exp | Name `=´ exp | exp fieldsep ::= `,´ | `;´ binop ::= `+´ | `-´ | `*´ | `/´ | `^´ | `%´ | `..´ | `<´ | `<=´ | `>´ | `>=´ | `==´ | `~=´ | and | or unop ::= `-´ | not | `#´


Team
habitar (noun): habit + avatar. Why not play a game that actually matters?
A habitar is your accountability buddy's best friend. Habitars are friendly bundles of joy (numbers and cultural enrichment) when the going is smooth. Don't be fooled by their friendly demeanor- when the going is tough, they'll notify your designated friends and family to help you get back on track.
Like behavioral sciences, programming, and/or drawing?
Send a note to<EMAIL_ADDRESS>We'd love to hear from you!


1. Identify main company domains (horizontal DNS enumeration)
2. Domain scraping for discovered domains
3. Domain bruteforcing, resolving and potentially adding new IP ranges
4. Portscan
5. Brutespray
5. Visual identification
6. Platform identification
7. Content discovery
8. Parameter discovery
9. Attacks


| JSON Sidekick |
| Introduction |
Suggestions welcome, please contact<EMAIL_ADDRESS>This plugin parses JSON files. See www.json.org for details of the JSON file format.
This is a fairly minimal sidekick, it only parses JSON files and is pretty strict about the format. Parsing errors are shown in the Error List plugin.
The parser itself is written using Antlr, so the Antlr plugin is a requirement.
| Settings |
There are no specific settings for this plugin. If the file type is recognized by jEdit as being a JSON file, this plugin will parse it and display a corresponding tree in the Sidekick.
| Version History |


MIMIMI.co
About
Help
Messages
Account
5
Notifications
Anthony Lagon
comments your item. Check it out.
Colin Devroe
likes your item. Now you have 17 likes
Josh Long
sent you a message!
Josh Long
sent you a message!
Art
Home & Living
Women
Men
Kids
Jewelry
Vintage
Gift ideas
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Elegant sketchbook was made with love and peace.
Notebooks
25.00
USD
Load more items


Windy Shaoring:
...What are you talking about? Those monsters say hello to me, and I say hello back to them. That's how you make friends, you know. Can't you hear what the monsters are saying, Mystic?
"You should go back home now!"


Quản trị viên
Nguyên
15
Hãng xe
20
Dáng xe
30
Bài đánh giá
100
Thông tin xe
Earning Graph
100
80
60
40
20
0
JAN
80%
FEB
50%
MAR
40%
APR
55%
MAY
20%
JUN
39%
JUL
75%
AUG
45%
SEP
50%
OCT
42%
NOV
60%
DEC
90%
Online Customers
John Doe
Dream Land, AU
3
Jonathan Smith
United States
5
Jane Doe
ABC, USA
Anjelina Joli
Fockland, UK
7
Mr Tasi
Dream Land, USA
pending Task
Dashboard v1.3
40%
40% Complete (success)
Database Update
60%
60% Complete (warning)
Iphone Development
87%
87% Complete
Mobile App
33%
33% Complete (danger)
Dashboard v1.3
45%
45% Complete
See All Tasks


realize(n, s)
Return a pair with the first n
elements of the sequence s
in its head and
the rest of s
in its tail.
realize(3, [1, 2, 3, 4, 5])
// [[1, 2, 3], 4, 5]
function ints(n) n:~ints(n+1)
let xs = ints(10)
realize(5, xs)
// [10, 11, 12, 13, 14]:15:<promise>
realize(3, tail(realize(5, xs)))
// [15, 16, 17]:18:<promise>


Modules: Complicated
Classes: Background, TypedFaceApp, TypedFaceView
Generated Feb 1, 2021 4:16:18 PM


| Job Title | {{selectedJob.title}} |
|---|---|
| Job Category | {{selectedJob.category}} |
| Job Description | {{selectedJob.description}} |
| Job Location | {{selectedJob.location}} |
| Time and Duration | {{selectedJob.date}} for {{selectedJob.duration}} {{selectedJob.timeUnit}} |
| Compensation |
${{selectedJob.lowerBound}}
From ${{selectedJob.lowerBound}} to ${{selectedJob.upperBound}}
|
| My Profile |
{{application.providerProfile.description}} |
{{chooseProviderProfileErrorMsg}} |
|---|---|---|
| Price $ | {{applicationPriceErrorMsg}} |


About Me
A background of my career, education and interests
Find Out More
My projects
Check out my cool projects
Find Out More
Contact Me
Let's talk
Find Out More


ApiError
public enum ApiError
ApiError
is the error type returned by HenriPoitierApi. It encompasses a few different types of errors, each with
their own associated reasons.
- unknownError: Returned when an error is unknown.
- invalidURL: Returned when a URL is invalid.
- jsonMappingFailed: Returned when the JSON mapping failed.
- parameterEncodingFailed: Returned when a parameter encoding object throws an error during the encoding process.
- responseValidationFailed: Returned when a response code is not valid.
- responseSerializationFailed: Returned when a response serializer encounters an error in the serialization process.
-
The underlying reason the parameter encoding error occurred.
- missingURL: The URL request did not have a URL to encode.
- jsonEncodingFailed: JSON serialization failed with an underlying system error during the encoding process.
- unknownReason: The failure reason is unknown.
Declaration
Swift
public enum ParameterEncodingFailureReason
-
The underlying reason the response validation error occurred.
- dataFileNil: The data file containing the server response did not exist.
- dataFileReadFailed: The data file containing the server response could not be read.
- missingContentType: The response did not contain a
Content-Type
and theacceptableContentTypes
provided did not contain wildcard type. - unacceptableContentType: The response
Content-Type
did not match any type in the providedacceptableContentTypes
. - unacceptableStatusCode: The response status code was not acceptable.
Declaration
Swift
public enum ResponseValidationFailureReason
-
The underlying reason the response serialization error occurred.
- inputDataNil: The server response contained no data.
- inputDataNilOrZeroLength: The server response contained no data or the data was zero length.
- inputFileNil: The file containing the server response did not exist.
- inputFileReadFailed: The file containing the server response could not be read.
- stringSerializationFailed: String serialization failed using the provided
String.Encoding
. - jsonSerializationFailed: JSON serialization failed with an underlying system error.
Declaration
Swift
public enum ResponseSerializationFailureReason
-
Undocumented
Declaration
Swift
case unknownError
-
Undocumented
Declaration
Swift
case invalidURL(url: URL?)
-
Undocumented
Declaration
Swift
case jsonMappingFailed(error: Error)
-
Undocumented
Declaration
Swift
case parameterEncodingFailed(reason: ParameterEncodingFailureReason)
-
Undocumented
Declaration
Swift
case responseValidationFailed(reason: ResponseValidationFailureReason)
-
Undocumented
Declaration
Swift
case responseSerializationFailed(reason: ResponseSerializationFailureReason)
-
The
Error
returned by a system framework associated with a.parameterEncodingFailed
, or.responseSerializationFailed
error.Declaration
Swift
public var underlyingError: Error?
-
The acceptable
Content-Type
s of a.responseValidationFailed
error.Declaration
Swift
public var acceptableContentTypes: [String]?
-
The response
Content-Type
of a.responseValidationFailed
error.Declaration
Swift
public var responseContentType: String?
-
The response code of a
.responseValidationFailed
error.Declaration
Swift
public var responseCode: Int?
-
The
String.Encoding
associated with a failed.stringResponse()
call.Declaration
Swift
public var failedStringEncoding: String.Encoding?
-
Declaration
Swift
public var errorDescription: String?


The game is played with a single six-sided dice. Roll dice as many times as you want and use the hold turn button to give your opponent a chance to play.


File provides functional level API prototypes for GPIO interface. More...
#include <ti/csl/src/ip/gpio/V0/cslr_gpio.h>
Data Structures | |
| struct | gpioContext |
| Structure holding the GPIO context. More... | |
Macros | |
| #define | GPIO_PIN_LOW (0x0U) |
| GPIO pin is at logic low. | |
| #define | GPIO_PIN_HIGH (0x1U) |
| GPIO pin is at logic high. | |
| #define | GPIO_OE_OUTPUTEN_N_ENABLED (0U) |
| Macro to configure GPIO pin as output. | |
| #define | GPIO_OE_OUTPUTEN_N_DISABLED (1U) |
| Macro to configure GPIO pin as input. | |
| #define | GPIO_PIN_MASK_ALL 0xFF |
| Mask for all pins of single gpio port. | |
Typedefs | |
| typedef struct gpioContext | gpioContext_t |
| Structure holding the GPIO context. | |
Functions | |
| void | GPIOSetDirMode_v0 (uint32_t baseAddr, uint32_t pinNumber, uint32_t pinDirection) |
| This API configures the direction of a specified GPIO pin as being either input or output. More... | |
| void | GPIOPinWrite_v0 (uint32_t baseAddr, uint32_t pinNumber, uint32_t pinValue) |
| This API drives an output GPIO pin to a logic HIGH or a logic LOW state. More... | |
| uint32_t | GPIOPinRead_v0 (uint32_t baseAddr, uint32_t pinNumber) |
| This API determines the logic level(value) on a specified GPIO pin. More... | |
| uint32_t | GPIOPinOutValueRead_v0 (uint32_t baseAddr, uint32_t pinNumber) |
| This API determines the output logic level(value) on a specified GPIO pin. More... | |
| void | GPIOSetIntrType_v0 (uint32_t baseAddr, uint32_t pinNumber, uint32_t eventType) |
| This API configures the event type for a specified input GPIO pin. Whenever the selected event occurs on that GPIO pin and if interrupt generation is enabled for that pin, the GPIO module will send an interrupt to CPU. More... | |
| void | GPIOIntrEnable_v0 (uint32_t baseAddr, uint32_t pinNumber, uint32_t eventType) |
| This API enables the configured interrupt event on a specified input GPIO pin to trigger an interrupt request. More... | |
| void | GPIOIntrDisable_v0 (uint32_t baseAddr, uint32_t pinNumber) |
| This API disables interrupt generation due to the detection of any event on a specified input GPIO pin. More... | |
| uint32_t | GPIOIntrStatus_v0 (uint32_t baseAddr, uint32_t pinNumber) |
| This API determines the enabled interrupt status of a specified pin. More... | |
| void | GPIOIntrStatusMask_v0 (uint32_t baseAddr, uint32_t bankIdx, uint32_t *intrStatusMask) |
| This API determines the enabled interrupt status of a specified pin. More... | |
| void | GPIOIntrClear_v0 (uint32_t baseAddr, uint32_t pinNumber) |
| This API clears the enabled interrupt status of a specified GPIO pin. More... | |
| void | GPIOIntrClearMask_v0 (uint32_t baseAddr, uint32_t bankIdx, uint32_t pinMask) |
| This API clears the enabled interrupt status of specified GPIO pins. More... | |
GPIO Interrupt mask | |
| #define | GPIO_INTR_MASK_NO_EDGE (0x01U) |
| #define | GPIO_INTR_MASK_RISE_EDGE (0x02U) |
| #define | GPIO_INTR_MASK_FALL_EDGE (0x04U) |
| #define | GPIO_INTR_MASK_BOTH_EDGE (0x08U) |
| typedef uint32_t | gpioIntrMask_t |
| Enumerates the possible GPIO interrupt generation events. | |
GPIO Direction | |
| #define | GPIO_DIRECTION_INPUT (GPIO_OE_OUTPUTEN_N_DISABLED) |
| #define | GPIO_DIRECTION_OUTPUT (GPIO_OE_OUTPUTEN_N_ENABLED) |
| typedef uint32_t | gpioDirection_t |
| Enumerates the direction of GPIO pin. | |
File provides functional level API prototypes for GPIO interface.
| #define GPIO_DIRECTION_INPUT (GPIO_OE_OUTPUTEN_N_DISABLED) |
Input pin.
| #define GPIO_DIRECTION_OUTPUT (GPIO_OE_OUTPUTEN_N_ENABLED) |
Output pin.
| #define GPIO_INTR_MASK_BOTH_EDGE (0x08U) |
Interrupt request on occurrence of both a rising and a falling edge on the pin.
| #define GPIO_INTR_MASK_FALL_EDGE (0x04U) |
Interrupt request on occurrence of a falling edge on the input GPIO pin.
| #define GPIO_INTR_MASK_NO_EDGE (0x01U) |
No interrupt request on either rising or falling edges on the pin.
| #define GPIO_INTR_MASK_RISE_EDGE (0x02U) |
Interrupt request on occurrence of a rising edge on the input GPIO pin.
| void GPIOIntrClear_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber | ||
| ) |
This API clears the enabled interrupt status of a specified GPIO pin.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63) |
| void GPIOIntrClearMask_v0 | ( | uint32_t | baseAddr, |
| uint32_t | bankIdx, | ||
| uint32_t | pinMask | ||
| ) |
This API clears the enabled interrupt status of specified GPIO pins.
| baseAddr | The memory address of the GPIO instance being used |
| bankIdx | Bank index of the GPIO instance |
| pinMask | Mask of pins whose interrupts need to be cleared for the GPIO bank. |
| void GPIOIntrDisable_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber | ||
| ) |
This API disables interrupt generation due to the detection of any event on a specified input GPIO pin.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63) |
| eventType | This specifies the event type on whose detection, the GPIO module will send an interrupt to CPU, provided interrupt generation for that pin is enabled. 'eventType' can take one of the following values following enum: |
| void GPIOIntrEnable_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber, | ||
| uint32_t | eventType | ||
| ) |
This API enables the configured interrupt event on a specified input GPIO pin to trigger an interrupt request.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63) |
| uint32_t GPIOIntrStatus_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber | ||
| ) |
This API determines the enabled interrupt status of a specified pin.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63) |
| int_status | The enabled interrupt status of the pin on the specified interrupt line. This could either be a non-zero or a zero value. |
| void GPIOIntrStatusMask_v0 | ( | uint32_t | baseAddr, |
| uint32_t | bankIdx, | ||
| uint32_t * | intrStatusMask | ||
| ) |
This API determines the enabled interrupt status of a specified pin.
| baseAddr | The memory address of the GPIO instance being used |
| bankIdx | Bank index of the GPIO instance |
| intrStatusMask | pointer of the interrupt status for the GPIO bank |
| uint32_t GPIOPinOutValueRead_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber | ||
| ) |
This API determines the output logic level(value) on a specified GPIO pin.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63) |
| GPIO_PIN_LOW | - indicating to drive a logic LOW(0) on the pin. |
| GPIO_PIN_HIGH | - indicating to drive a logic HIGH(1) on the pin. |
| uint32_t GPIOPinRead_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber | ||
| ) |
This API determines the logic level(value) on a specified GPIO pin.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63) |
| GPIO_PIN_LOW | - indicating to drive a logic LOW(0) on the pin. |
| GPIO_PIN_HIGH | - indicating to drive a logic HIGH(1) on the pin. |
| void GPIOPinWrite_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber, | ||
| uint32_t | pinValue | ||
| ) |
This API drives an output GPIO pin to a logic HIGH or a logic LOW state.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63). |
| pinValue | This specifies whether a logic HIGH or a logic LOW should be driven on the output pin. 'pinValue' can take one of the following values:
|
| void GPIOSetDirMode_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber, | ||
| uint32_t | pinDirection | ||
| ) |
This API configures the direction of a specified GPIO pin as being either input or output.
| baseAddr | The memory address of the GPIO instance being used. |
| pinNumber | The number of the pin in the GPIO instance. 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63). |
| pinDirection | The required direction for the GPIO pin. pinDirection' can take one of the value from the following enum: |
| void GPIOSetIntrType_v0 | ( | uint32_t | baseAddr, |
| uint32_t | pinNumber, | ||
| uint32_t | eventType | ||
| ) |
This API configures the event type for a specified input GPIO pin. Whenever the selected event occurs on that GPIO pin and if interrupt generation is enabled for that pin, the GPIO module will send an interrupt to CPU.
| baseAddr | The memory address of the GPIO instance being used |
| pinNumber | The number of the pin in the GPIO instance 'pinNumber' can take one of the following values: (0 <= pinNumber <= 63). |
| eventType | This specifies the event type on whose detection, the GPIO module will send an interrupt to CPU, provided interrupt generation for that pin is enabled. 'eventType' can take one of the following values following enum: |


Home
Product
Faq
Contact
Food app
Why stay hungry when
you can ordem form Bella Onojie
Download the bella onoje's food app now on
Playstore
App store
How the app works
Create an account
Create/login to an existing
account to get started
An account is created with your email
and a desired password
Explore varieties
Shop for your favorites
meal as e dey hot.
Shop for your favorite meals or drinks
and enjoy while doing it.
Checkout
When you done check out
and get it delivered
When you done check out and get it
delivered with ease.
download the app now.
Available on your favorite store. Start your premium experience now
Playstory
App story


However, only eight amino acids (except histidine) are considered essential for adult human.
However, heating should not always be viewed in a negative sense. Destruction of trypsin inhibitor and other anti-nutritional factors and detoxification (e.g. cooking cassava in open pans) due to heat are some advantages. Heating also increases the palatability and digestibility of food.
Germination can improve the nutritional value and digestibility of pulses. During germination, the vitamins, minerals and enzymes are increased. Thus, sprouted beans are nutritionally better than raw beans.


1 All these are the customs of Egyptians who live above the marsh country. Those who inhabit the marshes have the same customs as the rest of Egyptians, even that each man has one wife just like Greeks. They have, besides, devised means to make their food less costly.
2 When the river is in flood and flows over the plains, many lilies, which the Egyptians call lotus, grow in the water. They gather these and dry them in the sun; then they crush the poppy-like center of the plant and bake loaves of it.
3 The root of this lotus is edible also, and of a sweetish taste; it is round, and the size of an apple.
4 Other lilies grow in the river, too, that are like roses; the fruit of these is found in a calyx springing from the root by a separate stalk, and is most like a comb made by wasps; this produces many edible seeds as big as olive pits, which are eaten both fresh and dried.
5 They also use the byblus which grows annually: it is gathered from the marshes, the top of it cut off and put to other uses, and the lower part, about twenty inches long, eaten or sold. Those who wish to use the byblus at its very best, roast it before eating in a red-hot oven. Some live on fish alone. They catch the fish, take out the intestines, then dry them in the sun and eat them dried.


RotoQL
Extra info can be added here and we can add a button to open this on mobile.
Players
{{player.first_name}} {{player.last_name}}
Team: {{player.team}}
Position: {{player.position}}


Books of:
John Smith
Title:
DB Primer
Title:
Comp. Sys.
Award for Excellent writing
Best Young Author Award


Enums
The following enums are available globally.
-
Represents the type of a channel.
See moreDeclaration
Swift
public enum DiscordChannelType : Int
-
A enum representing a configuration option.
See moreDeclaration
Swift
public enum DiscordClientOption : CustomStringConvertible, Equatable
-
An enum that represents the dispatch events Discord sends.
If one of these events is handled specifically by the client then it will be turned into an event with the form
See moremyEventName
. If it is not handled, then the associated enum string will be the event name.Declaration
Swift
public enum DiscordDispatchEvent : String
-
This enum controls the interface with the Discord REST API.
It defines several endpoint cases which are then used by the various static methods defined on this enum. The cases themselves are of little use.
The methods all take a
DiscordToken
which is used for authentication with the REST API. GET methods also take a callback.All requests through this enum are rate limited.
NOTE: Callbacks from methods on this enum are NOT executed on the client’s handleQueue. So it is important that if you make modifications to the client inside of a callback, you first dispatch back on the handleQueue.
See moreDeclaration
Swift
public enum DiscordEndpoint : String
-
Top-level enum for gateway codes.
See moreDeclaration
Swift
public enum DiscordGatewayCode
-
Represents a regular gateway code
See moreDeclaration
Swift
public enum DiscordNormalGatewayCode : Int
-
Represents a voice gateway code
See moreDeclaration
Swift
public enum DiscordVoiceGatewayCode : Int
-
Represents the reason a gateway was closed.
See moreDeclaration
Swift
public enum DiscordGatewayCloseReason : Int
-
Holds a gateway payload, based on its type.
See moreDeclaration
Swift
public enum DiscordGatewayPayloadData
-
Represents the level of verbosity for the logger.
See moreDeclaration
Swift
public enum DiscordLogLevel
-
Represents the Discord OAuth endpoint.
See moreDeclaration
Swift
public enum DiscordOAuthEndpoint : String
-
Represents a Discord Permission. Calculating Permissions involves bitwise operations.
See moreDeclaration
Swift
public enum DiscordPermission : Int
-
Represents a permission overwrite type for a channel.
See moreDeclaration
Swift
public enum DiscordPermissionOverwriteType : String, JSONRepresentable


Detail-oriented IT professional with two years of experience as a quality assurance analyst testing software developed in house for consumer use. Previously fives years of experience as a service desk associate helping people with their hardware and software related issue. Skilled at operating in a wide range of platforms. Excellent written and oral communication skills; capable of explaining complex software issues in easy-to-understand terms. I also have the business background to understand where business needs align with the corporate goals for the company.
ResumeHTML, CSS, Bootstrap, JavaScript
Adobe Creative Suite, Photoshop, InDesgin, Illustrator
Works well in team settings


--- layout: single sidebar: false --- {% include base_path %}
Jones Lang LaSalle, a famous professional services and investment management company specializing in real estate, recently reported that Poland is “the leading outsourcing destination in Europe.”
Methodologies are used to structure projects and provide a course that avoids common pitfalls.
In today's rapidly developing and cut throat market economy, it is pertinent to deliver products to the market in a timely manner. What should one look for in the right outsourcing partner?
Outsourcing software development to third party companies brings great value to all sectors of the technology industry worldwide.


@* * Copyright 2023 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.platformstatusfrontend.config.AppConfig @import uk.gov.hmrc.platformstatusfrontend.services.PlatformStatus @this( layout : Layout, appConfig: AppConfig ) @(statusList: List[PlatformStatus])(implicit request: Request[_], messages: Messages) @layout(pageTitle = Some("Platform Status")) {
| @status.name | @status.description | Ticketyboo |
| @status.name | @status.description | @status.reason |
| @status.name | @status.description | N/A |
Experimental config value: @appConfig.experimentValue
Generate specific response codes
Measure Request/Response header and body sizes
Simulate generic request volumes
You are looking at the platform-status-frontend which runs in the public zone. It is running a few tests designed to exercise different bits of infrastructure. For some of the tests it calls through to the platform-status-backend which runs in the protected zone. Hopefully the tests are descriptive, but more info is available in github.
}


{# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -#} {% extends "manage_organization_base.html" %} {% import "warehouse:templates/includes/pagination.html" as pagination %} {% set active_tab = 'history' %} {% block title %}{% trans source_name=organization.name %}'{{ source_name }}' security history{% endtrans %}{% endblock %} {% block main %}
{% trans %}Each time you (or your collaborators) perform a security action related to this organization, the action is recorded and displayed here.{% endtrans %}
{% macro event_summary(event) -%} {# Keep in sync with: warehouse/events/tags.py #} {# Display action for catalog entry events #} {% if event.tag == EventTag.Organization.CatalogEntryAdd %} {% trans organization_name=event.additional.organization_name %}'{{ organization_name }}' registered as organization name{% endtrans %} {# Display action for organization events #} {% elif event.tag == EventTag.Organization.OrganizationCreate %} {% trans organization_name=event.additional.organization_name %}{{ organization_name }} organization created{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationDelete %} {% trans organization_name=event.additional.organization_name %}{{ organization_name }} organization deleted{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationRename %} {% trans organization_name=event.additional.organization_name, previous_organization_name=event.additional.previous_organization_name %}{{ previous_organization_name }} organization renamed to {{ organization_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationApprove %} {% trans organization_name=event.additional.organization_name %}{{ organization_name }} organization approved{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationDecline %} {% trans organization_name=event.additional.organization_name %}{{ organization_name }} organization declined{% endtrans %} {# Display action for organization project events #} {% elif event.tag == EventTag.Organization.OrganizationProjectAdd %} {% trans href=request.route_path('packaging.project', name=event.additional.project_name|canonicalize_name), project_name=event.additional.project_name %}{{ project_name }} project added to organization{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationProjectRemove %} {% trans href=request.route_path('packaging.project', name=event.additional.project_name|canonicalize_name), project_name=event.additional.project_name %}{{ project_name }} project removed from organization{% endtrans %} {# Display action for organization role events #} {% elif event.tag == EventTag.Organization.OrganizationRoleAdd %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, role_name=event.additional.role_name|lower %}{{ username }} added as organization {{ role_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationRoleRemove %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, role_name=event.additional.role_name|lower %}{{ username }} removed as organization {{ role_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationRoleChange %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, role_name=event.additional.role_name|lower %}{{ username }} changed to organization {{ role_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationRoleInvite %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, role_name=event.additional.role_name|lower %}{{ username }} invited to join as organization {{ role_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationRoleDeclineInvite %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, role_name=event.additional.role_name|lower %}{{ username }} declined invitation to join as organization {{ role_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.OrganizationRoleRevokeInvite %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, role_name=event.additional.role_name|lower %}Revoked invitation for {{ username }} to join as organization {{ role_name }}{% endtrans %} {# Display action for team events #} {% elif event.tag == EventTag.Organization.TeamCreate %} {% trans team_name=event.additional.team_name %}{{ team_name }} team created{% endtrans %} {% elif event.tag == EventTag.Organization.TeamDelete %} {% trans team_name=event.additional.team_name %}{{ team_name }} team deleted{% endtrans %} {# Display action for team project role events #} {% elif event.tag == EventTag.Organization.TeamProjectRoleAdd %} {% trans team_name=event.additional.target_team, role_name=event.additional.role_name|lower, href=request.route_path('packaging.project', name=event.additional.project_name|canonicalize_name), project_name=event.additional.project_name %}{{ team_name }} team added as project {{ role_name }} for {{ project_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.TeamProjectRoleRemove %} {% trans team_name=event.additional.target_team, role_name=event.additional.role_name|lower, href=request.route_path('packaging.project', name=event.additional.project_name|canonicalize_name), project_name=event.additional.project_name %}{{ team_name }} team removed as project {{ role_name }} for {{ project_name }}{% endtrans %} {% elif event.tag == EventTag.Organization.TeamProjectRoleChange %} {% trans team_name=event.additional.target_team, role_name=event.additional.role_name|lower, href=request.route_path('packaging.project', name=event.additional.project_name|canonicalize_name), project_name=event.additional.project_name %}{{ team_name }} team changed to project {{ role_name }} for {{ project_name }}{% endtrans %} {# Display action for team role events #} {% elif event.tag == EventTag.Organization.TeamRoleAdd %} {% set target_user = get_user(event.additional.target_user_id).username %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, team_name=event.additional.team_name %}{{ username }} added to {{ team_name }} team{% endtrans %} {% elif event.tag == EventTag.Organization.TeamRoleRemove %} {% trans href=request.route_path('accounts.profile', username=target_user), username=target_user, team_name=event.additional.team_name %}{{ username }} removed from {{ team_name }} team{% endtrans %} {% else %} {{ event.tag }} {% endif %} {# Display acting user for catalog entry events #} {% if event.tag == EventTag.Organization.CatalogEntryAdd %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Registered by:{% endtrans %} {{ submitted_by }} {# Display acting user for organization events and team events #} {% elif event.tag.endswith(":create") %} {% set created_by = get_user(event.additional.created_by_user_id).username %} {% trans %}Created by:{% endtrans %} {{ created_by }} {% elif event.tag.endswith(":delete") %} {% set deleted_by = get_user(event.additional.deleted_by_user_id).username %} {% trans %}Deleted by:{% endtrans %} {{ deleted_by }} {% elif event.tag.endswith(":rename") %} {% set renamed_by = get_user(event.additional.renamed_by_user_id).username %} {% trans %}Renamed by:{% endtrans %} {{ renamed_by }} {% elif event.tag.endswith(":approve") %} {% set approved_by = get_user(event.additional.approved_by_user_id).username %} {% trans %}Approved by:{% endtrans %} {{ approved_by }} {% elif event.tag.endswith(":decline") %} {% set declined_by = get_user(event.additional.declined_by_user_id).username %} {% trans %}Declined by:{% endtrans %} {{ declined_by }} {# Display submitting user for role events #} {% elif event.tag.endswith(":add") %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Added by:{% endtrans %} {{ submitted_by }} {% elif event.tag.endswith(":remove") %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Removed by:{% endtrans %} {{ submitted_by }} {% elif event.tag.endswith(":change") %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Changed by:{% endtrans %} {{ submitted_by }} {% elif event.tag.endswith(":invite") %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Invited by:{% endtrans %} {{ submitted_by }} {% elif event.tag.endswith(":decline_invite") %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Invited by:{% endtrans %} {{ submitted_by }} {% elif event.tag.endswith(":revoke_invite") %} {% set submitted_by = get_user(event.additional.submitted_by_user_id).username %} {% trans %}Revoked by:{% endtrans %} {{ submitted_by }} {% endif %} {%- endmacro %} {% if events %}| {% trans %}Event{% endtrans %} | {% trans %}Time{% endtrans %} | {% trans %}IP address{% endtrans %} |
|---|---|---|
| {{ event_summary(event) }} | {% trans %}Time{% endtrans %} {{ humanize(event.time, time="true") }} | {% trans %}IP address{% endtrans %} {{ event.ip_address }} |


Coloured Petri Nets are a high-level form of Petri Nets (see also this short tour of Petri nets), in which anonymous tokens are replaced by data objects of some programming language (and transitions can operate on that data, in addition to moving it around). The combination of functional languages and Petri nets promises a rich design space - the two formalisms have little overlap and much to offer to each other.
Coloured Petri nets with functional inscription languages are a well-established starting point on this route, but are usually associated with high startup costs wrt tool support. By embedding such nets in their inscription languages, it is possible to reduce these startup costs drastically (from years to weeks), and although the resulting quick-start toolsets will not be able to compete with those evolved over years, they offer a cheep and cheerful entry route. One can get started quickly, invest more time and resources where and when needed, and, crucially, have access to the source code for experimentation and extension.
At IFL 1999, we outlined these ideas for the concrete example of Haskell-Coloured Petri nets, giving a simple embedding of such nets in Haskell. Somewhat to our disappointment, there has so far not been an abundance of Haskell-, Clean-, Erlang-, .. coloured nets in practical use. So we've decided to follow up our outline by concrete prototypical tool support for Haskell-Coloured Petri nets (HCPN for short), hoping that others will be encouraged to follow suit for nets with inscriptions in their favourite functional programming language (if your favourite fpl happens to be SML, have a look at CPN/Tools, the successor of Design/CPN).
So far, we have a bare-bones graphical editor for HCPN, building on the portable wxHaskell GUI library (Haskell binding to wxWidgets). From this, HCPN can be saved, loaded, and exported as Haskell code for graphical or textual simulation. (HCPN NetEdit is not quite ready for prime time yet, but functional; as long as you promise not to look at the ugly code, you can find a snapshot of version 0.1 here [now updated for wxHaskell-0.8];-).
For the curious, here's a simple example, the infamous deadlocking philosophers. First, as a plain Petri net (note that anonymous tokens are modelled as empty products, which are elided by default from arc labels and place types):
Of course, using coloured nets, we can replace the anonymous tokens by data values, say Ints 0,1,2 for the three forks and similarly for the three philosophers. Once we can distinguish the tokens this way, we can fold the matching places together and, in fact, we can fold the matching transitions as well if we calculate the forks to work with from the philosopher number:
And here's an example textual simulation run of the latter HCPN:
Mark {forks = [0,1,2], phil_ready = [0,1,2], phil_has_both = [], phil_has_right = []} phil_takes_right Mark {forks = [1,2], phil_ready = [0,2], phil_has_both = [], phil_has_right = [1]} phil_takes_left Mark {forks = [1], phil_ready = [0,2], phil_has_both = [1], phil_has_right = []} phil_finished Mark {forks = [0,2,1], phil_ready = [1,0,2], phil_has_both = [], phil_has_right = []} phil_takes_right Mark {forks = [0,2], phil_ready = [1,0], phil_has_both = [], phil_has_right = [2]} phil_takes_right Mark {forks = [2], phil_ready = [0], phil_has_both = [], phil_has_right = [1,2]} phil_takes_left Mark {forks = [], phil_ready = [0], phil_has_both = [1], phil_has_right = [2]} phil_finished Mark {forks = [0,2], phil_ready = [1,0], phil_has_both = [], phil_has_right = [2]} phil_takes_left Mark {forks = [2], phil_ready = [1,0], phil_has_both = [2], phil_has_right = []} phil_takes_right Mark {forks = [], phil_ready = [1], phil_has_both = [2], phil_has_right = [0]} phil_finished Mark {forks = [1,0], phil_ready = [2,1], phil_has_both = [], phil_has_right = [0]} phil_takes_right Mark {forks = [0], phil_ready = [1], phil_has_both = [], phil_has_right = [2,0]} phil_takes_left Mark {forks = [], phil_ready = [1], phil_has_both = [2], phil_has_right = [0]} phil_finished Mark {forks = [1,0], phil_ready = [2,1], phil_has_both = [], phil_has_right = [0]} phil_takes_right Mark {forks = [1], phil_ready = [2], phil_has_both = [], phil_has_right = [1,0]} phil_takes_right Mark {forks = [], phil_ready = [], phil_has_both = [], phil_has_right = [2,1,0]} no more enabled transitions!
The Haskell code (here the older, slightly simpler version) generated is fairly recognizable, but not the kind of code you'd want to write by hand for larger nets:-)
-- generated by HCPN NetEdit v0.0 module Unnamed where import SimpleHCPN -- declarations -- markings data Mark = Mark { forks :: [Int] , phil_ready :: [Int] , phil_has_both :: [Int] , phil_has_right :: [Int] } deriving Show -- transition actions phil_finished :: Mark -> [Mark] phil_finished m = do let phil_has_both_marking = phil_has_both m let forks_marking = forks m let phil_ready_marking = phil_ready m (p, phil_has_both_marking) <- select $ phil_has_both_marking if True then return m{ phil_has_both = phil_has_both_marking , forks = ((p-1) `mod` 3) : ((p+1) `mod` 3) : forks_marking , phil_ready = (p) : phil_ready_marking } else fail "guard failed" phil_takes_left :: Mark -> [Mark] phil_takes_left m = do let forks_marking = forks m let phil_has_right_marking = phil_has_right m let phil_has_both_marking = phil_has_both m (f, forks_marking) <- select $ forks_marking (p, phil_has_right_marking) <- select $ phil_has_right_marking if f == ((p+1) `mod` 3) then return m{ forks = forks_marking , phil_has_right = phil_has_right_marking , phil_has_both = (p) : phil_has_both_marking } else fail "guard failed" phil_takes_right :: Mark -> [Mark] phil_takes_right m = do let forks_marking = forks m let phil_ready_marking = phil_ready m let phil_has_right_marking = phil_has_right m (f, forks_marking) <- select $ forks_marking (p, phil_ready_marking) <- select $ phil_ready_marking if f == ((p-1) `mod` 3) then return m{ forks = forks_marking , phil_ready = phil_ready_marking , phil_has_right = (p) : phil_has_right_marking } else fail "guard failed" -- transitions net = Net{trans=[ Trans{name="phil_finished",action=phil_finished} , Trans{name="phil_takes_left",action=phil_takes_left} , Trans{name="phil_takes_right",action=phil_takes_right} ]} -- initial marking mark = Mark{ forks = [0,1,2] , phil_ready = [0,1,2] , phil_has_both = [] , phil_has_right = [] } -- end
Another, possibly more interesting example is an embedding of a pi-calculus into HCPN. That this is possible may surprise those who still equate Petri nets entirely with the simple anonymous token variant, or presume that the static nature of Petri nets precludes the modeling of dynamic process systems, but the embedding is straightforward. One just has to decide which parts of the system to be modelled are static and which are dynamic, and of course, higher order abstract syntax using Haskell's anonymous functions helps to cope with the binding structure of this pi-calculus. The dynamic part is the "process soup", which is mapped onto a multiset of process tokens on a single place, and the static part are the reaction rules, which are mapped to a transition per rule (as a variation, replication is mapped to recursion in Haskell; either way, this isn't very practical - one would want to limit the use of replication in practice). This embedding is not specific to the pi-calculus, but covers multiset rewrite systems in general.
A few points to note about this example:
communication
transition uses a guard to
guarantee equality of sender and receiver channels. Permitting
repeated variables on the set of input arcs would be more concise,
but would complicate the embedding of HCPN in Haskell.


Uncovering tiles that don't have mines gives you points. Uncovering a mine makes you lose but you keep your points.


Rubric
Exercises
Mini-projects
Final
Grades
_________Name_____________Type____________Grade_________
1.
Exercises
Mini-Projects
Final
2.
Exercises
Mini-Projects
Final
3.
Exercises
Mini-Projects
Final
4.
Exercises
Mini-Projects
Final
Total


Made with favorite_border & sentiment_very_satisfied by Ankit Sridhar
Choose photos or add photos by url for processing. The image is sent to DeepAI GAN.
A deep learning model that has been trained on pairs of color images with their grayscale counterpart. After hours of training, the models learns how to add color back to black and white images.
Get your colorized version of your photo back from the image colorization model.


From your file, we extracted the following information. Please correct any inaccurate fields if necessary.
Fields with this icon next to them may especially require correction.
Click the pop-up icon to view the text as it appears in your file.
Click the pen icon to manually edit the field
| CRIME NAME | LOCATION | DATE | View | Edit |
|---|---|---|---|---|
data |
data |
data |
||
| data | data | data | ||
| data | data | data | ||
| data | data | data |


St. Petersburg man arrested, charged after woman's body found in trunk of his car, police say
by WFTS Digital StaffST. PETERSBURG, Fla. — St. Pete police arrested a man after they say a woman's body was found in the trunk of his car.
Police said detectives arrested Warren Brown, 57, for the murder of Sophie Solis at 7380 Organdy Dr. North on Saturday.
PINELLAS NEWS | The latest headlines from Pinellas County
Friends concerned for her Solis' welfare found her body in the trunk of Brown's car in the driveway last week. She was found stabbed.
Police say Brown was arrested just days before on Nov. 9 for aggravated assault and domestic battery after he cut Solis with a knife. He bonded out of jail and she dropped the charges, according to police.
Detectives also found photos of the couple and bloody clothing in the trunk, as well. When they went inside the home, they found blood spatter on the ceiling of two rooms.
Warren later admitted to police that he stabbed Solis and placed her in the trunk of his car.
Police said the couple had a history of domestic violence issues.


<lcModDate>
The <lcModDate> provides the project modification date.
Category: Learning and training: common content elements


About Us
The mission of Seattle Friends of Iceland | Íslandsvinir
is to create a social network of people interested in discovering, discussing,
celebrating, and promoting Icelandic arts and culture and to build social,
cultural, and economic relationships with peers in Iceland.
Seattle Friends of Iceland is a group of people in the Seattle area who
share a love for Iceland and Icelandic culture. Our main goal is to build a
stronger connection between Seattle and Iceland. We get together to discuss
books, films, art, current events in Iceland, and to share food, attend lectures,
practice our Icelandic (English is ok too!), and discuss our travels to
Iceland.
We meet as a group about once per month for an official meeting, but we also have
many smaller special interest groups that meet on their own schedules to participate
in activities they enjoy. These groups include:
Arts and Crafts | Cooking and Dining | Music | Literature | Movie Club | Travel | Language
Heritage and Ancestry | Old Nordic | Connection | Business Exchange | Current Events
If you're interested in joining us, please sign up for our
mailing list
and visit the
contact page
and get a hold of us!
Góð Kveðja,
Seattle Friends of Iceland


= open_form() ?>
| Customer Name | Cart Total | Cart Items | IP | Country |
|---|---|---|---|---|
| = $session_cart->information->name ?> | = format_currency($session_cart->cart_total)?> | = $session_cart->item_count ?> | = $session_cart->customer_ip ?> | = $session_cart->customer_country ?> | endforeach ?>
Location data provided by GeoLite data created by MaxMind, available from http://www.maxmind.com


{% extends 'common/panel.html' %} {% block panel %} {% load humanize %} {% load analysis_extras %}
| Human | |
| {{climate_impact}} | |
| Food | Water |
| {{default_value}} | {{default_value}} |
| Proportion Developed |
| {{human_influence|percentage:2}} |
| Human Consumption |
| {{human_consumption}}% of NPP |
| Protected Areas |
| {{default_value}} |
| Proportion Suitable for Agriculture |
| {{soil_suitability|percentage:0}} |
| Water Stress Index |
| {{rws_rating}} (RWSI = {{rws_index|floatformat:1}}) |
| Percentage of World's Population |
| {{perc_population|percentage:2}} |
| Estimated Population in Poverty |
| {{estimated_impovershed|intword}} |
| Percentage of World's Impoverished |
| {{perc_underweight_children|percentage:2}} |
{% endblock panel %}


 I was a kid with the worst sun burn ever and I didn’t understand I could overdose on the stuff. I had never done drugs before and probably didn’t understand what drugs were yet.
The sun burn was infected, and I had a fever. My whole back was ripped apart and leaking fluid, as were the backs of my legs, and I was in great pain, so I did what the bottle said to do and applied it to the effected area, my entire back and legs, which were of course open wounds too. I ignored that part. After I had finished I realized I’d probably gone through half the bottle just on my back. I had more Benadryl though so I also dosed the syrup and the pill form. I then try to sleep.
At first my clothes are very uncomfortable, so I strip them off but the bed sheet still feels like it is cutting into the wound on my back, so I pull that off as well. When I was a kid, of course, I was afraid of monsters, but not just any monsters, Aliens were my monster of choice. Aliens, of course, really exist and aren’t fake at all like other monsters and they also like to abduct children and do terrible things to them so it’s good to be scared of them. Taking my covers and clothing off had removed my Alien Shield, since they obvious will need direct access to my naked body if they are to experiment. I knew this, but I couldn’t do anything about it since clothes hurt so damned much to wear and sheets were even unbearable.
At this point the drug was kicking in. I did the smart thing and tried to rationalize that aliens didn’t exist.
I exploded from bed and ran down the hall naked, screaming. My parents burst out of their room and they start screaming and I was screaming and they screamed something at me about what happened and I screamed back “The Grays!” I should mention that I can’t remember how old I was, but I was certainly too old to be running down the halls screaming whenever I got scared. This wasn’t fear, it was a panic reflex.
After that I went back and fell asleep - woke up paralyzed.   I was convinced the aliens came back and abducted me, and I couldn’t move or speak save for a thin, raspy, repeated “help me wake me up” during all of it.
(Yes I do have the full abduction story that I can’t blame drugs 100% for. They came to my room and I saw them at the foot of my bed. I never saw the ship because I told them, with my mind how else, after they arrived that the reason humans were always scared of them was because of an inbuilt thing in their psyche that made us frightened of all other humanoid species. I rationalized to the aliens this was true. I told them to look at human on human conflict. I told them also that I was not trying to be rude or mean and they weren’t disgusting to behold just they were scary to me. I said the paralysis made it even worse. The aliens were very nice and told me they would put me to sleep so I would know that I was being abducted and could feel it but I wouldn’t be able to see them. This was my suggestion, but they understood my thoughts so well they knew what I wanted to ask.
Then my eyes closed and I could feel them touching me and injecting me in my chest with a long needle and it hurt bad so I scrunched up my eyes so they’d be closed even more. When I did that, the aliens stopped injecting me for a second and I got really numb and I couldn’t feel anything but their arms holding my arms down.  To my surprise, they were very long, nail less and it seemed I could always feel at least five digits, spread out palm flat on my chest, the needle in between them.
For the nay-sayers, yes, I remember this part vividly. I remember the hands were very firm and not soft at all but also not boney, working hands, doctors hands my mind said. I remember they never once grabbed me to hold me down and I thought at the time that it would be awkward to make a fist with such long fingers. They always touched me with their fingers length wise, if they needed to hold my arm, it was done at the elbow with several fingers extended onto my bicep and two digits holding my forearm.)
I woke up to a violent seizure and more sleep paralysis. The sleep paralysis continues to this day. The sleep seizures continued at least for a week afterward.  Each abduction happened like the last one, the aliens came at around 3 o-clock AM, I stayed up for them because I was scared, I could feel them coming. I’d suddenly fall asleep, then wake up, my eyes wouldn’t open though and I could feel them doing stuff to me. When they were done, they would leave at about Five AM. I lost the hours and it felt like only minutes. The seizure would begin at the end and continue on, it seemed, into daylight when I actually woke up, of course from being jostled around by seizure.
Today – I sleep crappy and am still scared of aliens. I also had this peculiar bump on my chest where I thought I had been injected. It developed days after the initial “abduction” and I remember I thought there was a needle hole sealing up on top of it. During P.E. in High School I got hit by a baseball on that exact spot. (my sternum) It became mysteriously infected despite the fact there was no cut, and since my sunburn I haven’t had an infection.
To sum it up: I am still not sure whether or not I was abducted by Aliens. I have had problems sleeping since that day.  I probably have lingering psychotic effects and occasionally I break into a state of mind which I would describe as a flashback. My face gets red and I start to think like I am tripping again, I then exhibit all the symptoms of schizophrenia I can in a short time span and return to normal within a half hour.
  Taking a cataclysmic amount of a terrible drug when I was like 10 years old definitely colored my perception of that nights’ event.  If the Benadryl bit didn’t happen, the Aliens would have seemed completely believable.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


[ ß ]
- ♥ App still in pre-beta stage.
- ♥ Keep away from five year olds and blondes.
- ♥ Your fault if it breaks.
- ♥ Do report any 'oh shit!' moments.
Shell
- ♥ LOL: Toggles LOLPython mode.
- ♥ theme: Could it have been named with any more modesty?
- ♥ print: Well... It prints.
- ♥ clear: Yeah, it fills up the screen with random text... C'mon!
Badges
- ♥ Lover. Trust me, you're just getting started.
- ♥ Rookie. The Basics.
- ♥ Master.  Apply at Google.
- ♥ God. Why don't you get in touch with Guido?
Feedback
- ♥ Hope you had fun.
- ♥ Spread the love. Talk about it!
- ♥ Feedback link is always floating around on top. :-)
{% if iOS %}
{% endif %}


Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222
Todo here right?
1 May, 1222


#include <tiffio.h> tdata_t _TIFFmalloc(tsize_t); tdata_t _TIFFrealloc(tdata_t, tsize_t); void _TIFFfree(tdata_t); void _TIFFmemset(tdata_t, int, tsize_t); void _TIFFmemcpy(tdata_t, const tdata_t, tsize_t); int _TIFFmemcmp(const tdata_t, const tdata_t, tsize_t);
_TIFFmalloc and _TIFFrealloc are used to dynamically allocate and reallocate memory used by libtiff; such as memory passed into the I/O routines. Memory allocated through these interfaces is released back to the system using the _TIFFfree routine.
Memory allocated through one of the above interfaces can be set to a known value using _TIFFmemset, copied to another memory location using _TIFFmemcpy, or compared for equality using _TIFFmemcmp. These routines conform to the equivalent ANSI C routines: memset, memcpy, and memcmp, repsectively.


This button is enabled if any update actions have been placed in the Ameol outbasket but haven't yet been actioned.
If any update items are deleted from the outbasket, they will be locked out by Moderate. Clicking on this reset button removes the lock and allows updates to occur again.


Personal blog for Vishad
Powered by Hugo
You can visit the list page of a single section, e.g., posts, notes, or papers.


This is a heading level one (
h1
)
This is a heading level two (
h2
)
This is a heading level three (
h3
)
This is a heading level four (
h4
)
This is a heading level five (
h5
)
This is a heading level six (
h6
)