Free conditional tense software for linux

Rational PIC Assembler is an assembler for the mid-range microcontrollers from Microchip. The project uses Intel style mnemonics and target-first operand ordering. Designed to feel comfortable to PC assembly programmers.
This assembler generates code compatible with Microchips midline microcontrollers but is incompatible with their assembler. It should feel familiar to any PC assembly programmer. The instruction mnemonics and operand order are Intel style ( i.e. right, as opposed to wrong ).
Command Line Syntax
pic-asm [ -c ] [ -l filename ] [ -o filename ] input_file
-c -- console mode
an assembly source is accepted from stdin. binary code is
output on stdout. errors are output to stderr
-l filename -- specify listing file
-o filename -- specify object file
Input
The input is a sequence of line each of which contains one or more of the following fields
label instruction operands ; comment
The label and comment are optional. The operands required depend on the instruction.
The assembler is case sensitive, even for instructions.
Constants
Hex values can be specified with C-style 0x[:xdigit:]+. Binary values can be specified with 0b[01]+. Decimal values require no prefix as decimal is the default base.
Character constants are specified by enclosing a single character or escaped character within single quotes. String constants are specified by enclosing zero or more characters and escaped characters within double quotes. String constants generate one character constant for each character in the string. There is no trailing zero stored. For example:
db "Hello worldn", 0, a, b, r, n, t
Labels
A label is a sequence of alphanumeric characters ( including underbar ) that starts a line. Labels do not have colons. Labels local to the last nonlocal label can be defined by prefixing the name with a dot. For instance
; example from example-1.asm
foo call .1
.1 jmp .2
.2 jmp .1
bar call .1
.1 jmp .2
.2 jmp .1
In this example, the labels defined are foo, foo.1, foo.2, bar, bar.1, and bar.2. The first call branches to foo.1. The second call branches to bar.1. The labels local to foo can not be referenced before foo has been declared nor after bar has been declared.
Directives
Data can be declared. The declarator takes the place of the instruction and is followed by one or more expressions separated by commas. Each expression corresponds to one word in the output code regardless of the declarator type.
db - each operand is AND-ed with 0xff before being stored
dw - full 14 bit word definition
dt - each operand is AND-ed with 0xff and OR-ed with 0x3400 ( the return-with-value opcode ). This allows generation of case tables. You can add the accumulator ( w ) to the offset of the table. The processor will branch to the location in the table and return with an eight bit result
For instance:
db 1,2,3
dw 0x3fff, 0x3ff * 16 + 15, -1
dt 0b001, 0b010, 0b100
Equates are a named sequence of tokens. They can be defined with equ. For instance:
led_1 equ 0x100 | 1
led_2 equ 0x100 | 2
combo equ ( led_1 ) | ( led_2 )
The org position can be changed with org. For instance
org 0x10o
Enhancements:
- This release adds support for sophisticated macros, include files, conditional compilation, and compatibility with Microchip headers.

Dystopia is a Half-Life 2 modifcation which places the player into tense combat situations in a high tech world spanned by computer networks. As either Punks or Corp Mercenaries the player will fight through the physical world to gain access, via jack-in terminals, to cyberspace.

Cyberspace is a three dimensional representation of the worlds network. Inside cyberspace players will launch programs to hack into systems linked to the physical world, fight off enemy hackers or defend critical systems. Gameplay progresses through inter-linked physical and cyberspace objectives, some are completed in either the physical world or cyberspace, others only by a well timed combination of the two.

The player will be immersed in action packed battles, whether as a heavily augmented combat mercenary armed to the teeth with the latest in firepower and implants, or a twitch reflex cyberdecker racing to infiltrate a cyberspace node. Only through skillful use of the high tech arsenal were making available and intelligent team play will players truly jack-in and kick ass.

Note: System used was Ubuntu Breezy Badger 2.6.12-9

Installation:

Log in as root

Create a user (EX. hlds, dystopia, srcds, etc..) with the command:

adduser hlds

Give that user a password

passwd hlds

Create a directory somewhere as that user where the server files and game files will go and go to that directory

mkdir /home/hlds/srcds

Make the owner of that directory your new user

chown hlds /home/hlds/srcds

Either login as that user or change to that user with the command

su hlds

Get the linux hlds update tool accurate as of 2/22/07

wget http://storefront.steampowered.com/download/hldsupdatetool.bin

Change the file to be executable

chmod ugo+x hldsupdatetool.bin

Run the hldsupdatetool.bin

./hldsupdatetool.bin

If you see an error about not finding /bin/uncompress type

ln -s /bin/gunzip /bin/uncompress && ./hldsupdatetool.bin

Answer the agreement
Run the steam file that is extracted

./steam

It will update itself and then tell you to rerun the command, do so, but changed. This will take a while

./steam -command update -game hl2mp -dir .

Download the Dystopia V1 server package

wget dystopia_v1_server.tar.gz

Extract the files in your srcds folder

tar -xvzf dystopia_v1_server.tar.gz

Configuration:

Edit ~/srcds/dystopia/cfg/server.cfg with your editor of choice. This file is run at every map change.

Comment out or remove the following line.

map dys_assemble

This must be done or you server will not start properly.
Edit ~/srcds/dystopia/cfg/valve.rc with your editor of choice. This file is run at server start

Add in the line the following line.

map dys_assemble

This map can be whatever you like your server to start on. If you do not do this, your server will not start properly.
Edit ~/srcds/dystopia/motd.txt with your editor of choice
Edit ~/srcds/dystopia/mapcycle.txt with your editor of choice

Starting the Server - Basic

Go to your srcds directory, whatever it is named

cd ~/srcds

Use the following command to start your server, this is a basic setup, replace 1.1.1.1 with the ip you want your server to report. You can also leave out the +ip 1.1.1.1 and it will take the first IP it can get

./srcds_run -game dystopia_v1 +maxplayers 20 -ip 1.1.1.1 -port 27015 &

To bring the console back so you can type commands into the console. use the command

fg

This will not always work.

The drawback to this method is that once you start it and then exit your ssh session you will not be able to get it back (at least I dont know of a way, if you do, let me know and Ill add it)

Starting the server - Advanced

Check to see if you have the screen command

screen

If you do, proceed, if not, get it. Create a shell script with the following commands. To do so, open a file in your favorite text editor (*nix only please). I named the file serverStart.sh

#!/bin/sh echo "Starting Dystopia Beta Server" sleep 1 cd /home/hlds/srcds screen -A -m -S dystopia /home/hlds/srcds/srcds_run -game dystopia_v1 +maxplayers 20 -ip 1.1.1.1 -port 27015

Make the shell script executable

chmod ugo+x serverStart.sh

Once its up and running, to exit the screen without closing it use the following key combo

ctrl+A,D (ctrl+A and then while still holding a, press d)

To retrieve the screen so that you can look at the console

screen -r

PAPI aims to provide the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors.
PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
The Performance API (PAPI) project specifies a standard application programming interface (API) for accessing hardware performance counters available on most modern microprocessors.
These counters exist as a small set of registers that count Events, occurrences of specific signals related to the processors function. Monitoring these events facilitates correlation between the structure of source/object code and the efficiency of the mapping of that code to the underlying architecture.
This correlation has a variety of uses in performance analysis including hand tuning, compiler optimization, debugging, benchmarking, monitoring and performance modeling. In addition, it is hoped that this information will prove useful in the development of new compilation technology as well as in steering architectural development towards alleviating commonly occurring bottlenecks in high performance computing.
PAPI provides two interfaces to the underlying counter hardware; a simple, high level interface for the acquisition of simple measurements and a fully programmable, low level interface directed towards users with more sophisticated needs.
The low level PAPI interface deals with hardware events in groups called EventSets. EventSets reflect how the counters are most frequently used, such as taking simultaneous measurements of different hardware events and relating them to one another.
For example, relating cycles to memory references or flops to level 1 cache misses can indicate poor locality and memory management. In addition, EventSets allow a highly efficient implementation which translates to more detailed and accurate measurements.
EventSets are fully programmable and have features such as guaranteed thread safety, writing of counter values, multiplexing and notification on threshold crossing, as well as processor specific features. The high level interface simply provides the ability to start, stop and read specific events, one at a time.
PAPI provides portability across different platforms. It uses the same routines with similar argument lists to control and access the counters for every architecture. As part of PAPI, we have predefined a set of events that we feel represents the lowest common denominator of every good counter implementation.
Our intent is that the same source code will count similar and possibly comparable events when run on different platforms. If the programmer chooses to use this set of standardized events, then the source code need not be changed and only a fresh compilation and link is necessary. However, should the developer wish to access machine specific events, the low level API provides access to all available events and counting modes.
If an event or feature does not exist on the current platform, PAPI returns an appropriate error code. This significantly reduces the porting effort of code using PAPI because the semantics of each call to PAPI remains the same, just the argument lists need updating. In addition to the standard set, each PAPI implementation supports all native events through the ability to directly accept platform specific counter numbers. Definitions for most, if not all of these, are included as conditional macros in the header file. In this way, PAPI avoids having inefficient code to translate all events for all platforms into a uniform representation and back again.
This translation is only done for the relatively few events defined in the standardized set. Some processors like those in the POWER series have counter groups. They enable access to specific groups of counters, instead of individual events. This presents a serious portability problem, thus PAPI abstracts hardware counters from their groups with a packed naming scheme. Each counter control value or event is made up of the counter group number and the number of the specific counter in that group.
PAPI can be divided into two layers of software. The upper layer consists of the API and machine independent support functions. The lower layer defines and exports a machine independent interface to machine dependent functions and data structures. These functions access the substrate, which may consist of the operating system, a kernel extension or assembly functions to directly access the processors registers.
PAPI tries to use the most efficient and flexible of the three, depending on what is available. Naturally, the functionality of the upper layers heavily depends on that provided by the substrate. In cases where the substrates do not provide highly desirable features, PAPI attempts to emulate them as described below.
PAPI makes sure the underlying operating system or library guards against overflow of counter values.
Each counter can potentially be incremented multiple times in a single clock cycle. This combined with increasing clock speeds and the small precision of some of the physical counters means that overflow is likely to occur.
One of the more advanced features of PAPI is to provide a portable implementation of asynchronous notification when counters exceed a user specified value.
This functionality provides the basis for PAPIs SVR4 compatible profiling calls, that generate an accurate histogram of performance interrupts based on hardware metrics, not on time. Such functionality provides the basis for all line level performance analysis software, from the antiquated days of AT&Ts prof to SGIs SpeedShop. Thus for any architecture with even the most rudimentary access to hardware performance counters, PAPI provides the foundation for a truly portable, source level, performance analysis tool based on real processor statistics.
Enhancements:
- The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

Locale::Maketext::Simple is a simple interface to Locale::Maketext::Lexicon.

SYNOPSIS

Minimal setup (looks for auto/Foo/*.po and auto/Foo/*.mo):

package Foo;
use Locale::Maketext::Simple; # exports loc
loc_lang(fr); # set language to French
sub hello {
print loc("Hello, [_1]!", "World");
}
More sophisticated example:

package Foo::Bar;
use Locale::Maketext::Simple (
Class => Foo, # search in auto/Foo/
Style => gettext, # %1 instead of [_1]
Export => maketext, # maketext() instead of loc()
Subclass => L10N, # Foo::L10N instead of Foo::I18N
Decode => 1, # decode entries to unicode-strings
Encoding => locale, # but encode lexicons in current locale
# (needs Locale::Maketext::Lexicon 0.36)
);
sub japh {
print maketext("Just another %1 hacker", "Perl");
}

This module is a simple wrapper around Locale::Maketext::Lexicon, designed to alleviate the need of creating Language Classes for module authors.
If Locale::Maketext::Lexicon is not present, it implements a minimal localization function by simply interpolating [_1] with the first argument, [_2] with the second, etc. Interpolated function like [quant,_1] are treated as [_1], with the sole exception of [tense,_1,X], which will append ing to _1 when X is present, or appending ed to otherwise.

mod_ifexists module provides Apache conditional configuration process by the existence of the file.

XOTcl (XOTcl, pronounced exotickle) is an object-oriented scripting language based on MITs OTcl. XOTcl is intended as a value added replacement for OTcl.
XOTcl is an open source project which was initiated by Gustaf Neumann and Uwe Zdun, its main developers. The following people have contributed to XOTcl: Neophytos Demetriou, Fredj Dridi, Laurent Duperval, Teemu Hukkanen, MichaelL@frogware.com, Kristoffer Lawson, David LeBlanc, Catherine Letondal, Antti Salonen, Daniel Steffen, and Zoran Vasiljevic.
Scripting languages, like Tcl, are designed for glueing components together, provide features like dynamic extensibility and dynamic typing with automatic conversion, that make them well suited for rapid application development.
The basic object system of XOTcl is adopted from OTcl. The object system enables us to define objects, classes, and meta-classes. Classes are special objects with the purpose of managing other objects. ``Managing means that a class controls the creation and destruction of its instances and that it contains a repository of methods accessible for the instances.
Every object may be enhanced with object-specific methods. XOTcl supports single and multiple inheritance. All relationships in XOTcl, including class and superclass relationships, are completely dynamic and can be introspected. Through method chaining without explicit naming of the intended method, ambiguities in name resolution of methods are avoided. This way a shadowed method can be ``mixed into the execution of the current method.
XOTcl combines the ideas of scripting and object-orientation in a way that preserves the benefits of both of them. It is equipped with several new language functionalities that help building and managing complex systems. We added the following support:
Main features:
- Dynamic Object Aggregations, to provide dynamic aggregations through nested namespaces (objects).
- Nested Classes, to reduce the interference of independently developed program structures.
- Assertions, to reduce the interface and the reliability problems caused by dynamic typing and, therefore, to ease the combination of many components.
- Meta-data, to enhance self-documentation of objects and classes.
- Per-object mixins, as a means to improve flexibility of mixin methods by giving an object access to several different supplemental classes, which may be changed dynamically.
- Per-class mixins, as a means to improve flexibility of mixin methods to a class, all instances of the class have access to the mixed in methods like for multiple inheritance, but without the need of intersection classes.
- Filters (per class and per object) as a means of abstractions over method invocations to implement large program structures, like design patterns.
- Conditional Filters and Mixins can be used to perform context aware composition depending on guards (conditions which decide whether the interceptor should be used). All kinds of filters or mixins can be used conditionally.
- Dynamic Component Loading XOTcl integrates the Tcl package loading with architectrual support for integration with object-oriented constructs. Moreover, it provides tracking/tracing of component loading.

TinyButStrong is a template class for PHP that allows you to generate HTML pages using a database like PostgreSQL, MySQL, SQLite in native, and any other databases.
It is possible to design templates using any visual HTML editor (like Dreamweaver or FrontPage).
It features simple block management, useful display formats, conditional displaying for blocks and locators, a cache system, and the ability to include other HTML pages and execute associated scripts.
Main features:
- an connect to any database type (in native: MySql, SQLite, PostgreSQL),
- easy date-time and numeric formats,
- blocks with alternated display,
- multi-columns display,
- conditional display,
- event functions,
- file inclusion and other scripts execution,
- cache system.
Enhancements:
- This is a major version.
- The source is optimized, it is smaller, and it merges faster.
- There are 5 bugs fixed and 7 new features.
- It includes Onload Var fields that can be automatically merged when the template is loaded.
- There are new formats for time without leading zeros.
- The parameter ope can support several operations.
- There are special Var fields to merge PHP constants and to display TBS detailed information.