teamnwah
/
openmw-tes3coop
forked from mirror/openmw-tes3mp
2
0
Fork 1
Code Issues Pull Requests 1 Releases Wiki Activity

Cleaned up some old D files

Browse Source
actorid
Nicolay Korslund 15 years ago
parent 4ecb63203b
commit 29522f57d3
117 changed files with 1 additions and 33561 deletions
Show Stats Download Patch File Download Diff File

24
.gitignore vendored
Unescape Escape View File

@ -1,23 +1 @@
screenshot*.png build
*.o
*.a
*~
data
CMakeFiles
CMakeCache.txt
Makefile
cmake*.cmake
Ogre.log
ogre.cfg
build*
plugins.cfg
openmw.cfg
Doxygen
.thumbnails
resources
mwcompiler
mwinterpreter
clientconsole
MyGUI.log
mygui_test
mygui_test.png

247
old_d_version/COMPILE-linux.txt
Unescape Escape View File

@ -1,247 +0,0 @@
OpenMW - the completely unofficial reimplementation of Morrowind
================================================================
OpenMW is an open source reimplementation of the Morrowind game
engine. For more information, see README.txt or
http://openmw.snaptoad.com/
Installation from source
========================
Supported Unix platforms:
-------------------------
OpenMW has been tested for the most part on 32bit Ubuntu Linux
8.04. It should, however, also work on most other 32bit
distributions.
FreeBSD is also known to work with recent versions of GDC (the D
compiler), but you might need to rebuild some of the dependencies from
source yourself. (If you have done this and can give more specific
instructions, please let me know!)
64bit systems are NOT supported.
If you manage to build OpenMW on a platform not listed here, or want
to try, please let me know!
Dependencies:
-------------
Dependencies needed to build OpenMW:
OGRE 1.6.2 (3d engine)
OIS-1.0.0 (input system)
MyGUI 2.2.2 (GUI system for OGRE)
Bullet 2.74 (collision and physics library)
Monster 0.12 (scripting engine, included)
OpenAL (3d sound system)
libavcodec,
libavformat (For MP3 playback)
gcc and g++ (C++ compiler)
GNU make (build tool for C++ files)
DMD 1.036 (D compiler)
or GDC 4.1.3 (alternative D compiler)
The above versions are the ones I have tested recently, but other
versions might work. OGRE, OpenAL and the other libraries have
dependencies of their own, so I recommend using an automated package
tool to install as many of these as possible. On Ubuntu, for example,
try typing:
sudo apt-get install libogre-dev libavcodec-dev libavformat-dev libois-dev build-essential g++ gdc
On Arch Linux, get the following packages from AUR:
ogre
mygui-svn
bullet-2.75
openal
ffmpeg
ois
dmd
libphobos
dsss
(On Arch you also need to change the Bullet libraries to
-llBulletDynamics -llBulletCollision -llLinearMath in dsss.conf, or
similarily in the Makefile if you prefer building with make.)
A note about OpenAL: The library found in most Linux distributions
(0.0.8 SI) is outdated. Some distributions are now changing to OpenAL
Soft, which has a less hardware-dependent implementation. If you
experience sound problems (like stuttering music), try switching to
OpenAL Soft.
Note to UBUNTU 8.10 users: There's a problem with Pulseaudio in this
Ubuntu version. If you find that sound doesn't work or you get error
messages related to sound, try this page:
http://idyllictux.wordpress.com/2008/10/29/alsa-instead-of-pulseaudio-for-ubuntu-810-intrepid-a-non-destructive-way/
libavcodec and libavformat are part of the FFmpeg package, which is
part of the 'mplayer' project. Note that some of the codecs might be
patent protected in your country or area.
If you want to install Ogre, Bullet, OpenAL, OIS or FFmpeg manually,
try:
OGRE: http://ogre3d.org/
MyGUI: http://www.ogre3d.org/wiki/index.php/MyGUI
OpenAL: http://openal.org/
Linux source: http://kcat.strangesoft.net/openal.html
OIS: http://sourceforge.net/projects/wgois/
FFmpeg: http://ffmpeg.mplayerhq.hu/download.html
Bullet: http://bulletphysics.com/
Monster: Included with OpenMW.
Setting up Bullet
-----------------
Bullet is not yet included in most Linux distributions, and must
usually be compiled manually. Consult the documentation included with
Bullet for instructions on compiling.
After compiling, you should have the files libbulletdynamics.a,
libbulletcollision.a and libbulletmath.a. (Depending on build method,
you may end up with names like libLibBulletDynamics.a instead.) Copy
or link these to bullet/ in the openmw directory (and rename them to
the libbulletdynamics.a etc if necessary.)
Example:
cd openmw/bullet
ln -s ~/software/bullet-2.74/src/BulletCollision/libbulletcollision.a .
Next, create a link to the "src" directory in openmw/include/bullet/ .
Example:
cd openmw
mkdir -p include
cd include
ln -s ~/software/bullet-2.74/src bullet
Setting up MyGUI
----------------
Like Bullet, MyGUI is still too fresh to be prepackaged with the major
Linux distros. To make matters worse, there's not even a recent source
package. You'll need to get the source from svn (at
https://my-gui.svn.sourceforge.net/svnroot/my-gui/trunk ). Revisions
at around 1738 should work, but newer revisions are probably better.
Once you've compiled the sources, install normally using 'make
install' (check the MyGUI docs for any instructions), and the OpenMW
makefile should pick up its location automatically.
Choosing a D compiler
---------------------
The above apt-get command installs the GDC compiler. There are
currently two choices for the D compiler, DMD and GDC. DMD is the
"official" compiler and is updated more often, while GDC is a
completely open source front-end for GCC (the GNU compiler.) Both
should work equally well with OpenMW.
If you want to install GDC manually, go to
http://sourceforge.net/projects/dgcc
If you want to use DMD instead, it can be found at:
http://digitalmars.com/d/1.0/dmd-linux.html
Note that the DMD unstable branch (2.000 and up) will NOT currently
work with OpenMW. Use the stable branch (1.x) instead.
Also note that DMD is only available on 32 bit x86 Linux - other
operating systems or architectures will have to use GDC. Note however
that GDC might be unstable on these platforms as well, especially on
64 bit platforms.
Building:
---------
After installing all the dependencies, you can try running "make cpp"
first to see if the C++ parts compile. You may need to alter the
Makefile if you are using non-standard include paths, etc. If you have
DSSS installed (a D build tool), type:
dsss build
If you do NOT have DSSS, try using make
make all
You might need to edit the Makefile to match your setup. If you are
using DMD instead of GDC, try changing the compiler from "gdmd" to
"dmd" in the Makefile.
If all else fails, you can try the build script:
./build_openmw.sh
This build method is deprecated and only works with gdc.
Configuration
=============
Before you can run OpenMW, you have to help it find the Morrowind data
files. The 'openmw' program needs the files Morrowind.esm and
Morrowind.bsa, and the directories Sound/ and Music/ from your
"Morrowind\Data Files\" directory. By default it expects to find these
in the data/ directory. (This can be changed in openmw.ini)
I recommend creating a symbolic link to your original Morrowind
install. For example, if you have Morrowind installed in:
c:\Program Files\Bethesda Softworks\Morrowind\
and your windows c: drive is mounted on /media/hda1, then run the
following command:
ln -s "/media/hda1/Program Files/Bethesda Softworks/Morrowind/Data Files/" data
Also, if you have OGRE installed in a non-standard directory (ie. NOT
in /usr/lib/OGRE), you have to change the PluginFolder in the file
plugins.cfg.linux.
The first time you run openmw you will be asked to set screen
resolution and other graphics settings. You can bring this dialogue up
at any time with the -oc command line switch. I don't recommend using
fullscreen mode yet, since it might mess up your screen and input
settings if the program crashes.
Running OpenMW
==============
If Azura is with you and all the stars and planets are aligned in your
favor, you should now be able to run OpenMW using the program called
'openmw'.
Write openmw -h to see a list of options.
Running without parameters should bring you into the cave called Assu,
or the last cell loaded. Move around with WASD (or arrow keys), change
physics mode (walking, flying, ghost) with 't', exit with 'q' or
escape.
To load another cell, specify the cell name on the command line. Use
the 'esmtool' program to get a list of cells. Note that you must use
quotation marks "" if the cell name contains spaces or other weird
characters.
Enjoy! ;-)

83
old_d_version/COMPILE-win32.txt
Unescape Escape View File

@ -1,83 +0,0 @@
OpenMW - the completely unofficial reimplementation of Morrowind
================================================================
OpenMW is an open source reimplementation of the Morrowind game
engine. For more information, see README.txt or
http://openmw.snaptoad.com/
Building from source
====================
Supported Windows platforms:
----------------------------
Mostly tested on Windows XP, but Vista is also rumored to work. If you
manage to compile or run OpenMW on another Windows platform
(9x/Me/NT/2000), please let me know.
At the moment, only command line building is supported.
Dependencies:
-------------
To compile OpenMW you need Mingw with g++ (a C++ compiler) and gdc
(the D compiler.) You can find them here:
Mingw: http://sourceforge.net/projects/mingw/
gdc: http://sourceforge.net/projects/gdcwin/
Note that the "official" D compiler, DMD, will not currently work on
Windows, because it is uses an object format incompatible with most
C++ compilers.
All library dependencies are included in the file
openmw-dll-pack.zip. Simply download this file and unpack it in the
same directory as the OpenMW source code. You should not need to
download any other dependencies.
Setting everything up
---------------------
First, install Mingw (get the automatic installer.) Make sure gcc and
g++ packages are selected.
Next install the gdcwin installer (the package named 'gdc') and
install it in the same directory as Mingw.
Open a command line. Set up your PATH to include Mingw and gdc
(eg. "set PATH=%PATH%;c:\mingw\bin").
Next you must make sure the D include files are found by the
compiler. Run the following command:
set DFLAGS=-Ic:\mingw\include\d\3.4.5\
where the path following -I is the path of your Mingw GDC include
directory.
Make sure the commands g++ and gdc work (should output "no input
files".)
Building
--------
To build, simply run build_openmw.bat
Running
-------
For instructions on how to set everything up after compilation, see
README-win32.txt.
Good luck!

115
old_d_version/Makefile
Unescape Escape View File

@ -1,115 +0,0 @@
# Designed for GNU Make
# Compiler settings
CXXFLAGS?= -g
DMD=gdmd -version=Posix
# Some extra flags for niftool and bsatool
NIFFLAGS=-debug=warnstd -debug=check -debug=statecheck -debug=strict -debug=verbose
# Linker flags
LFLAGS= -L-lopenal -L-lOgreMain -L-lOIS -L-lmygui -L-luuid -L-lavcodec -L-lavformat bullet/libbulletdynamics.a bullet/libbulletcollision.a bullet/libbulletmath.a
# Compiler settings for Ogre, OIS and MyGUI
# TODO: the -I when we're done
CF_OIS=$(shell pkg-config --cflags OIS OGRE MyGUI) -Iterrain/
OGCC=$(CXX) $(CXXFLAGS) $(CF_OIS)
# Compiler settings for ffmpeg.
CF_FFMPEG=$(shell pkg-config --cflags libavcodec libavformat)
AVGCC=$(CXX) $(CXXFLAGS) $(CF_FFMPEG)
# Settings for Bullet
CF_BULLET=-Iinclude/bullet
BGCC=$(CXX) $(CXXFLAGS) $(CF_BULLET)
# Ogre C++ files, on the form ogre/cpp_X.cpp. Only the first file is
# passed to the compiler, the rest are dependencies.
ogre_cpp=ogre framelistener interface bsaarchive
# MyGUI C++ files, gui/cpp_X.cpp. These are currently included
# cpp_ogre.o with cpp_ogre.cpp.
mygui_cpp=mygui console
# Ditto for the landscape engine, in terrain/cpp_X.cpp
terrain_cpp=baseland terrain mesh
# FFmpeg files, in the form sound/cpp_X.cpp.
avcodec_cpp=avcodec
# Bullet cpp files
bullet_cpp=bullet player scale
#### No modifications should be required below this line. ####
ogre_cpp_files=\
$(ogre_cpp:%=ogre/cpp_%.cpp) \
$(mygui_cpp:%=gui/cpp_%.cpp) \
$(terrain_cpp:%=terrain/cpp_%.cpp)
avcodec_cpp_files=$(avcodec_cpp:%=sound/cpp_%.cpp)
bullet_cpp_files=$(bullet_cpp:%=bullet/cpp_%.cpp)
# All object files needed by openmw and esmtool
src := $(wildcard bsa/*.d) $(wildcard bullet/*.d) $(wildcard core/*.d) \
$(wildcard esm/*.d) $(wildcard input/*.d) $(wildcard nif/*.d) $(wildcard ogre/*.d) \
$(wildcard scene/*.d) $(wildcard sound/*.d) $(wildcard util/*.d) $(wildcard gui/*.d)
src := $(src) $(wildcard mscripts/*.d) $(wildcard terrain/*.d)
src := $(src) monster/monster.d \
$(wildcard monster/vm/*.d) \
$(wildcard monster/compiler/*.d) \
$(wildcard monster/util/*.d) \
$(wildcard monster/modules/*.d)
obj := $(src:%.d=objs/%.o)
# The NIF object files for niftool and bsatool are put in a separate
# directory, since they are built with different flags.
src_nif := $(wildcard nif/*.d)
src_nif := $(src_nif) $(wildcard util/*.d)
src_nif := $(src_nif) core/memory.d
src_nif := $(src_nif) $(wildcard monster/util/*.d)
obj_nif := $(src_nif:%.d=nifobjs/%.o)
.PHONY: cpp all clean
# Build everything. Default when running 'make' directly.
all: openmw esmtool niftool bsatool bored
# Only build C++ sources. Used when building from DSSS.
cpp: cpp_ogre.o cpp_avcodec.o cpp_bullet.o
cpp_ogre.o: $(ogre_cpp_files)
$(OGCC) -o $@ -c $<
cpp_avcodec.o: $(avcodec_cpp_files)
$(AVGCC) -o $@ -c $<
cpp_bullet.o: $(bullet_cpp_files)
$(BGCC) -o $@ -c $<
objs/%.o: %.d
dirname $@ | xargs mkdir -p
$(DMD) -c $< -of$@
nifobjs/%.o: %.d
dirname $@ | xargs mkdir -p
$(DMD) $(NIFFLAGS) -c $< -of$@
openmw: openmw.d cpp_ogre.o cpp_avcodec.o cpp_bullet.o $(obj)
$(DMD) $^ -of$@ $(LFLAGS)
esmtool: esmtool.d cpp_ogre.o cpp_avcodec.o cpp_bullet.o $(obj)
$(DMD) $^ -of$@ $(LFLAGS)
niftool: niftool.d $(obj_nif)
$(DMD) $^ -of$@
bsatool: bsatool.d $(obj_nif) objs/bsa/bsafile.o
$(DMD) $^ -of$@
bored: bored.d
$(DMD) $^
clean:
-rm -f cpp_bullet.o cpp_ogre.o cpp_avcodec.o bored.o bsafile.o bsatool.o esmtool.o niftool.o openmw.o
-rm -f openmw esmtool niftool bsatool bored
-rm -rf objs/ nifobjs/ dsss_objs/

54
old_d_version/README-win32.txt
Unescape Escape View File

@ -1,54 +0,0 @@
OpenMW - the completely unofficial reimplementation of Morrowind
================================================================
OpenMW is an open source reimplementation of the Morrowind game
engine. For more information, see README.txt or
http://openmw.snaptoad.com/
Running OpenMW
==============
OpenMW consists of three separate downloads:
openmw-0.X_win32.zip - binary package (with EXE file)
openmw-0.X.zip - source code
openmw-dll-pack.zip - library pack
You only need the binary or the source package, not both. The DLL pack
is needed in both cases.
NOTE: If downloaded the SOURCE release, please read COMPILE-win32.txt
before reading the rest of this file.
Configuration
-------------------
OpenMW assumes you have the Morrowind data files in c:\Program
Files\Bethesda Softworks\Morrowind\Data Files\ . If this is not where
you have installed Morrowind, you should edit the file openmw.ini.
Running
-------
Just run openmw.exe and enjoy! ;-)
The first time you run OpenMW, you will be asked to set screen
resolution and other graphics settings. To be safe, I don't recommend
setting fullscreen mode on the first run. You can bring up the
dialogue at any time by using the -oc switch.
Move around with WASD or arrow keys, change physics mode (walking,
flying, ghost) with 't', exit with 'q' or escape. You can change key
bindings in the openmw.ini file.
You start in a cell called "Assu". You can change this in openmw.ini or
by specifying a cell name on the command line.
Write openmw -h on the command line to see a complete list of options.

111
old_d_version/README.txt
Unescape Escape View File

@ -1,111 +0,0 @@
OpenMW - the completely unofficial reimplementation of Morrowind
================================================================
Written by Nicolay Korslund
Email: korslund@gmail.com
WWW: http://openmw.sourceforge.net
License: See GPL3.txt
Current version: 0.6
Date: 2009 mar. 2
QUICK NOTE: You must own and install Morrowind before you can use
OpenMW. Let me repeat that: OpenMW will NOT run if you do not have
Morrowind installed on your system!
Installation
============
Currently supported platforms are Windows, Linux and FreeBSD. Most
testing is done on Ubuntu 8.04 and Windows XP Professional.
For instructions, see one of the following:
README-win32.txt - instructions for binary Windows release
COMPILE-win32.txt - instructions for building from source on Windows
COMPILE-linux.tx - instructions for building from source on Linux / Unix
Linux 64 does NOT work, because of problems with the D compiler. We
hope to sort this out at some point, but right now it's simply not
supported.
Programs included in this package:
==================================
openmw - The main program. Run openmw -h for a list of options.
esmtool - Used to inspect ES files (ESM, ESP, ESS). Run without
arguments to get a list of options.
bsatool - Tool for viewing and extracting files from BSA archives.
(Can also be used to test the NIF parser on a BSA.)
niftool - Decodes one or more NIF files and prints the details.
Changelog:
==========
0.6 (2009 mar. 2) - latest release
- coded a GUI system using MyGUI
- skinned MyGUI to look like Morrowind (work in progress)
- integrated the Monster-script engine
- rewrote some parts into script code
- very early MyGUI <-> Monster binding
- fixed Windows sound problems (replaced old openal32.dll)
0.5 (2008 nov. 5)
- Collision detection with Bullet
- Experimental walk & fall character physics
- New key bindings:
t - toggle physics mode (walking, flying, ghost)
n - night-eye: brightens the scene
- Fixed incompatability with DMD 1.032 and newer
- Various minor changes and updates
0.4 (2008 aug. 30)
- switched from Audiere to OpenAL (BIG thanks to Chris Robinson)
- added complete Makefile (again) as a alternative build tool
- more realistic lighting (thanks again to Chris Robinson)
- various localization fixes - tested with Russian and French versions
- temporary workaround for the Unicode issue: invalid UTF displayed as '?'
- added -ns option to disable sound, for debugging
- various bug-fixes
- cosmetic changes to placate gdc -Wall
0.3 (2008 jul. 10)
- built and tested on Windows XP
- partial support for FreeBSD (exceptions do not work)
- temporarily dropped DSSS and Monster as necessary dependencies
- renamed main program from 'morro' to 'openmw'
- made the config system more robust
- added -oc switch for showing Ogre config window on startup
- removed some config files, these are auto-generated when
missing. Separated plugins.cfg into linux and windows versions.
- updated Makefile and sources for increased portability (thanks to
Dmitry Marakasov.)
- tested against OIS 1.0.0 (Ubuntu repository package)
0.2 (2008 jun. 17)
- compiles with gdc
- switched to DSSS for building D code
- includes the program esmtool
0.1 (2008 jun. 03)
- first release

11
old_d_version/build_openmw.bat
Unescape Escape View File

@ -1,11 +0,0 @@
@echo off
rem See COMPILE-win32.txt for instructions.
echo Compiling C++ files
g++ -c sound\cpp_avcodec.cpp -I.\includes\ffmpeg\
g++ -c ogre\cpp_ogre.cpp -I.\includes\ogre\ -I.\includes\mygui\
g++ -c bullet\cpp_bullet.cpp -I.\includes\bullet\
echo Compiling main program (openmw.exe)
gdc -g openmw.d bsa\*.d core\*.d esm\*.d input\*.d nif\*.d ogre\*.d scene\*.d sound\*.d util\*.d bullet\*.d cpp_ogre.o cpp_avcodec.o cpp_bullet.o libbulletdynamics.a libbulletcollision.a libbulletmath.a mscripts\setup.d monster\monster.d monster\compiler\*.d monster\vm\*.d monster\util\*.d monster\modules\*.d avcodec-51.dll avformat-52.dll avdevice-52.dll avutil-49.dll openal32.dll mygui.a freetype6.dll -lole32 ogremain_d.dll OIS_d.dll -lstdc++ -o openmw.exe

275
old_d_version/core/inifile.d
Unescape Escape View File

@ -1,275 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (inifile.d) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module core.inifile;
import std.stdio;
import std.stream;
import std.string;
import std.path;
import std.file;
import monster.util.string;
import monster.util.aa;
void safeMkdir(char[] npath)
{
char curDir[];
int index = 0;
int srch;
do
{
while(npath[index..$].begins("/"))
index++;
srch = npath[index..$].find('/');
if(srch == -1)
curDir = npath;
else
{
index += srch;
curDir = npath[0..index];
}
index++;
if(!exists(curDir) || !isdir(curDir))
mkdir(curDir);
}
while(srch != -1)
}
// Writes an ini file.
struct IniWriter
{
File ini;
bool firstSection = true;
void openFile(char[] file)
{
if(ini is null) ini = new File();
char[] oldFile = file~".old";
if(exists(file))
copy(file, oldFile);
// Make sure the output directory exists
char[] dr = getDirName(file);
if(dr.length)
safeMkdir(dr);
ini.open(file, FileMode.OutNew);
}
void close()
{
ini.close();
}
void section(char[] name)
{
if(firstSection)
firstSection = false;
else
ini.writefln();
ini.writefln("[%s]", name);
}
void comment(char[] str)
{
ini.writefln("; %s", str);
}
void writeType(T)(char[] name, T t)
{
ini.writefln("%s=%s", name, t);
}
alias writeType!(int) writeInt;
alias writeType!(char[]) writeString;
void writeFloat(char[] name, float f)
{
ini.writefln("%s=%.3s", name, f);
}
void writeBool(char[] name, bool b)
{
ini.writefln("%s=%s", name, b?"yes":"no");
}
}
// Keytype that holds section name and variable name
struct SecVar
{
private:
char[] section;
char[] variable;
public:
bool opEquals(ref SecVar v)
{
return section == v.section && variable == v.variable;
}
uint toHash()
{
const auto ID = typeid(char[]);
return ID.getHash(&section) + ID.getHash(&variable);
}
static SecVar opCall(char[] sec, char[] var)
{
SecVar sv;
sv.section = sec;
sv.variable = var;
return sv;
}
char[] toString()
{
return "[" ~ section ~ "]:" ~ variable;
}
}
struct IniReader
{
private:
HashTable!(SecVar, char[]) vars;
char[] section;
// Start a new section
void setSection(char[] sec)
{
section = sec.dup;
}
// Insert a new value from file
void set(char[] variable, char[] value)
{
vars[SecVar(section, variable.dup)] = value.dup;
}
public:
void reset()
{
vars.reset();
section = null;
wasRead = false;
}
int getInt(char[] sec, char[] var, int def)
{
char[] value;
if(vars.inList(SecVar(sec,var), value))
return cast(int)atoi(value);
else
return def;
}
float getFloat(char[] sec, char[] var, float def)
{
char[] value;
if(vars.inList(SecVar(sec,var), value))
return atof(value);
else
return def;
}
char[] getString(char[] sec, char[] var, char[] def)
{
char[] value;
if(vars.inList(SecVar(sec,var), value))
return value;
else
return def;
}
// Return true if the string matches some case of 'yes', and false
// otherwise.
bool getBool(char[] sec, char[] var, bool def)
{
char[] value;
if(vars.inList(SecVar(sec,var), value))
return icmp(value, "yes") == 0;
else
return def;
}
bool wasRead = false;
void readFile(char[] fn)
{
// Reset this struct
reset();
// If the file doesn't exist, simply exit. This will work fine,
// and default values will be used instead.
if(!exists(fn)) return;
wasRead = true;
// Read buffer. Finite in size but perfectly safe - the readLine
// routine allocates more mem if it needs it.
char[300] buffer;
scope File ini = new File(fn);
while(!ini.eof)
{
char[] line = ini.readLine(buffer);
// Remove leading and trailing whitespace
line = strip(line);
// Ignore comments and blank lines
if(line.length == 0 || line.begins(";")) continue;
// New section?
if(line.begins("["))
{
if(!line.ends("]"))
{
//writefln("Malformed section: %s", line);
continue;
}
setSection(line[1..$-1]);
continue;
}
// Split line into a key and a value
int index = line.find('=');
if(index != -1)
{
char[] value = line[index+1..$];
line = line[0..index];
set(line, value);
}
//else writefln("Malformed value: '%s'", line);
}
}
}

60
old_d_version/core/memory.d
Unescape Escape View File

@ -1,60 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (memory.d) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module core.memory;
import util.regions;
// Global memory managers used by various loading routines
RegionManager
esmRegion, // Memory used by ESMs, BSAs and plugins. Cleared only
// when all files are reloaded. Lifetime is current
// plugin setting session - if we change the set of
// plugins, this region is reset and everything is
// reloaded.
gameRegion, // Memory used in current game. Cleared whenever a new
// game is loaded. Lifetime is the current game
// session, loading a saved game will reset the
// region.
nifRegion; // Used by the NIF loader. Cleared when a NIF file has
// been inserted into OGRE and the file data is no
// longer needed. In other words this is cleared
// immediately after loading each NIF file.
// AA allocator that uses esmRegion
struct ESMRegionAlloc
{
static const bool autoinit = false;
static void* alloc(uint size) { return esmRegion.allocate(size).ptr; }
static void free(void* p) { }
}
void initializeMemoryRegions()
{
// Default block sizes are probably ok
esmRegion = new RegionManager("ESM");
gameRegion = new RegionManager("GAME");
nifRegion = new RegionManager("NIF");
}

508
old_d_version/core/resource.d
Unescape Escape View File

@ -1,508 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (resource.d) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module core.resource;
import std.stdio;
import std.string;
import std.stream;
import std.file;
import std.path;
import monster.util.aa;
import monster.util.string;
import bsa.bsafile;
import bullet.bindings;
import core.memory;
import core.config;
import ogre.bindings;
import ogre.meshloader;
import sound.audio;
import sound.sfx;
import nif.nif;
import core.filefinder;
// These are handles for various resources. They may refer to a file
// in the file system, an entry in a BSA archive, or point to an
// already loaded resource. Resource handles that are not implemented
// yet are typedefed as ints for the moment.
typedef int IconIndex;
alias SoundResource* SoundIndex;
alias TextureResource* TextureIndex;
alias MeshResource* MeshIndex;
ResourceManager resources;
// Called from ogre/cpp_bsaarchive.cpp. We will probably move these
// later.
extern(C)
{
// Does the file exist in the archives?
int d_bsaExists(char *filename)
{
char[] name = toString(filename);
auto res = resources.lookupTexture(name);
if(res.bsaFile != -1)
return 1;
return 0;
}
// Open a file. Return the pointer and size.
void d_bsaOpenFile(char *filename,
void **retPtr, uint *retSize)
{
char[] name = toString(filename);
void[] result;
//writefln("calling d_bsaOpenFile(%s, %s)", bsaFile, name);
auto tex = resources.lookupTexture(name);
if(tex.bsaFile == -1) result = null;
else result = resources.archives[tex.bsaFile].findSlice(tex.bsaIndex);
*retPtr = result.ptr;
*retSize = result.length;
}
}
struct ResourceManager
{
private:
// Holds lists of resources in the file system.
FileFinder
meshes,
icons,
textures,
sounds,
bookart,
bsa, esm, esp;
// Archives
BSAFile archives[];
// List of resources that have already been looked up (case
// insensitive)
HashTable!(char[], MeshIndex, ESMRegionAlloc, CITextHash) meshLookup;
HashTable!(char[], TextureIndex, ESMRegionAlloc, CITextHash) textureLookup;
HashTable!(char[], SoundIndex, ESMRegionAlloc, CITextHash) soundLookup;
public:
// Hack. Set to true in esmtool to disable all the lookup*
// functions.
bool dummy = false;
void initResources()
{
bsa = new FileFinder(config.bsaDir, "bsa", Recurse.No);
archives.length = bsa.length;
foreach(int i, ref BSAFile f; archives)
f = new BSAFile(bsa[i+1]);
sounds = new FileFinder(config.sndDir);
// Simple playlists, similar to the Morrowind one. Later I imagine
// adding an interactive MP3 player with a bit more finesse, but
// this will do for now.
char[][] music;
char[][] getDir(char[] dir)
{
dir = FileFinder.addSlash(dir);
char[][] res = ((exists(dir) && isdir(dir)) ? listdir(dir) : null);
foreach(ref char[] fn; res)
fn = dir ~ fn;
return res;
}
Music.setPlaylists(getDir(config.musDir),
getDir(config.musDir2));
meshLookup.reset();
textureLookup.reset();
soundLookup.reset();
meshBuffer[0..7] = "meshes\\";
texBuffer[0..9] = "textures\\";
}
// These three functions are so similar that I should probably split
// out big parts of them into one common function.
SoundIndex lookupSound(char[] id)
{
if(dummy) return null;
assert(id != "", "loadSound called with empty id");
SoundIndex si;
if( soundLookup.inList(id, si) ) return si;
si = esmRegion.newT!(SoundResource);
// Check if the file exists
int index = sounds[id];
// If so, get the real file name
if(index) si.file = sounds[index];
// Otherwise, make this an empty resource
else
{
//writefln("Lookup failed to find sound %s", id);
si.file = null;
}
si.res.loaded = false;
// Copy name and insert. We MUST copy here, since indices during
// load are put in a temporary buffer, and thus overwritten.
si.name = esmRegion.copyz(id);
assert(si.name == id);
soundLookup[si.name] = si;
return si;
}
// Quick but effective hack
char[80] meshBuffer;
MeshIndex lookupMesh(char[] id)
{
if(dummy) return null;
MeshIndex mi;
// If it is already looked up, return the result
if( meshLookup.inList(id, mi) ) return mi;
mi = esmRegion.newT!(MeshResource);
// If not, find it. For now we only check the BSA.
char[] search;
if(id.length < 70)
{
// Go to great lengths to avoid the concat :) The speed gain
// is negligible (~ 1%), but the GC memory usage is HALVED!
// This may mean significantly fewer GC collects during a long
// run of the program.
meshBuffer[7..7+id.length] = id;
search = meshBuffer[0..7+id.length];
}
else
search = "meshes\\" ~ id;
//writefln("lookupMesh(%s): searching for %s", id, search);
mi.bsaIndex = -1;
mi.bsaFile = -1;
foreach(int ind, BSAFile bs; archives)
{
mi.bsaIndex = bs.getIndex(search);
if(mi.bsaIndex != -1) // Found something
{
mi.bsaFile = ind;
break;
}
}
if(mi.bsaIndex == -1)
{
//writefln("Lookup failed to find mesh %s", search);
assert(mi.bsaFile == -1);
}
// Resource is not loaded
mi.node = null;
// Make a copy of the id
mi.name = esmRegion.copyz(id);
meshLookup[mi.name] = mi;
return mi;
}
char[80] texBuffer;
// Checks the BSAs / file system for a given texture name. Tries
// various Morrowind-specific hacks, like changing the extension to
// .dds and adding a 'textures\' prefix. Does not load the texture.
TextureIndex lookupTexture(char[] id)
{
if(dummy) return null;
TextureIndex ti;
// Checked if we have looked it up before
if( textureLookup.inList(id, ti) ) return ti;
// Create a new resource locator
ti = esmRegion.newT!(TextureResource);
ti.name = esmRegion.copyz(id);
ti.newName = ti.name;
ti.type = ti.name[$-3..$];
void searchBSAs(char[] search)
{
// Look it up in the BSA
ti.bsaIndex = -1;
ti.bsaFile = -1;
foreach(int ind, BSAFile bs; archives)
{
ti.bsaIndex = bs.getIndex(search);
if(ti.bsaIndex != -1) // Found something
{
ti.bsaFile = ind;
break;
}
}
}
void searchWithDDS(char[] search)
{
searchBSAs(search);
// If we can't find it, try the same filename but with .dds as
// the extension. Bethesda did at some point convert all their
// textures to dds to improve loading times. However, they did
// not update their esm-files or require them to use the
// correct extention (if they had, it would have broken a lot
// of user mods). So we must support files that are referenced
// as eg .tga but stored as .dds.
if(ti.bsaIndex == -1 && ti.type != "dds")
{
search[$-3..$] = "dds";
searchBSAs(search);
if(ti.bsaIndex != -1)
{
// Store the real name in newName.
ti.newName = esmRegion.copyz(ti.name);
// Get a slice of the extension and overwrite it.
ti.type = ti.newName[$-3..$];
ti.type[] = "dds";
}
}
}
// Search for 'texture\name' first
char[] tmp;
if(id.length < 70)
{
// Avoid memory allocations if possible.
tmp = texBuffer[0..9+id.length];
tmp[9..$] = id;
}
else
{
tmp = "textures\\" ~ id;
writefln("WARNING: Did an allocation on %s", tmp);
}
searchWithDDS(tmp);
// Not found? Try without the 'texture\'
if(ti.bsaIndex == -1)
{
tmp = tmp[9..$];
tmp[] = id; // Reset the name (replace .dds with the original)
searchWithDDS(tmp);
}
// Check that extensions match, to be on the safe side
assert(ti.type == ti.newName[$-3..$]);
if(ti.bsaIndex == -1)
{
//writefln("Lookup failed to find texture %s", tmp);
assert(ti.bsaFile == -1);
}
textureLookup[ti.name] = ti;
return ti;
}
IconIndex lookupIcon(char[] id) { return -3; }
// Inserts a given mesh into ogre. Currently only reads the BSA
// file. Is only called from within MeshResource itself, and should
// never be called when the mesh is already loaded.
private void loadMesh(MeshIndex mi)
in
{
assert(!mi.isLoaded);
assert(!mi.isEmpty);
}
body
{
// Get a slice of the mesh
void[] s = archives[mi.bsaFile].findSlice(mi.bsaIndex);
// Load the NIF into memory. No need to call close(), the file is
// automatically closed when the data is loaded.
nifMesh.open(s, mi.name);
// Load and insert nif
// TODO: Might add BSA name to the handle name, for clarity
meshLoader.loadMesh(mi.name, mi.node, mi.shape);
// TODO: We could clear the BSA memory mapping here to free some
// mem
}
}
struct SoundResource
{
private:
char[] name;
char[] file;
SoundFile res;
public:
char[] getName() { return name; }
SoundInstance getInstance()
in
{
assert(!isEmpty());
}
body
{
if(!isLoaded())
res.load(file);
return res.getInstance();
}
bool isEmpty() { return file == ""; }
bool isLoaded() { return res.loaded; }
}
struct MeshResource
{
private:
char[] name;
int bsaFile;
int bsaIndex;
// Points to the 'template' SceneNode of this mesh. Is null if this
// mesh hasn't been inserted yet.
NodePtr node;
public:
// Bullet collision shape. Can be null.
BulletShape shape;
NodePtr getNode()
in
{
assert(!isEmpty());
}
body
{
if(node == null) resources.loadMesh(this);
return node;
}
char[] getName() { return name; }
// Returns true if this resource does not exist (ie. file not found)
// TODO: This must be modified later for non-BSA files.
bool isEmpty()
{
return bsaIndex == -1;
}
// Returns true if resource is loaded
bool isLoaded()
{
return node != null;
}
}
struct TextureResource
{
private:
char[] name;
char[] newName; // Converted name, ie. with extension converted to
// .dds if necessary
int bsaFile; // If set to -1, the file is in the file system
int bsaIndex;
char[] type; // Texture format, eg "tga" or "dds";
public:
char[] getName() { return name; }
char[] getNewName() { return newName; }
// Returns true if this resource does not exist (ie. file not found)
bool isEmpty()
{
return bsaIndex == -1;
}
}
// OLD STUFF
/+
void initResourceManager()
{
// Find all resource files
char[] morroDir = config.morrowindDirectory();
bsa = new FileFinder(morroDir, "bsa");
// Jump to the data files directory
morroDir = config.dataFilesDirectory();
esm = new FileFinder(morroDir, "esm", Recurse.No);
esp = new FileFinder(morroDir, "esp", Recurse.No);
meshes = new FileFinder(morroDir ~ "Meshes");
icons = new FileFinder(morroDir ~ "Icons");
textures = new FileFinder(morroDir ~ "Textures");
sounds = new FileFinder(morroDir ~ "Sound");
bookart = new FileFinder(morroDir ~ "BookArt");
char[][] bsas = config.bsaArchives();
archives.length = bsas.length;
writef("Loading BSA archives...");
writefln(" Done\n");
}
}
+/

1686
old_d_version/monster/compiler/assembler.d
View File

File diff suppressed because it is too large Load Diff

165
old_d_version/monster/compiler/block.d
Unescape Escape View File

@ -1,165 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (block.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.block;
import monster.compiler.tokenizer;
import monster.compiler.scopes;
import monster.compiler.assembler;
import monster.vm.error;
// Base class for all kinds of blocks. A 'block' is a token or
// collection of tokens that belong together and form a syntactical
// unit. A block might for example be a statement, a declaration, a
// block of code, or the entire class.
abstract class Block
{
protected:
static Token next(ref TokenArray toks)
{
if(toks.length == 0)
fail("Unexpected end of file");
Token tt = toks[0];
toks = toks[1..toks.length];
return tt;
}
static Floc getLoc(TokenArray toks)
{
Floc loc;
if(toks.length) loc = toks[0].loc;
return loc;
}
static bool isNext(ref TokenArray toks, TT type)
{
Floc ln;
return isNext(toks, type, ln);
}
static bool isNext(ref TokenArray toks, TT type, out Floc loc)
{
if( toks.length == 0 ) return false;
loc = toks[0].loc;
if( toks[0].type != type ) return false;
next(toks);
return true;
}
static bool isNext(ref TokenArray toks, TT type, out Token tok)
{
if( toks.length == 0 ) return false;
if( toks[0].type != type ) return false;
tok = next(toks);
return true;
}
// Is the next token a separator, ie. a ; or a new line
static bool isSep(ref TokenArray toks, TT symbol = TT.Semicolon)
{
if( toks.length == 0 ) return true;
if( toks[0].newline ) return true;
return isNext(toks, symbol);
}
// Returns true if the next token is on a new line. Does not remove
// any tokens.
static bool isNewline(ref TokenArray toks)
// TT.EMPTY never occurs in the stream, so it's safe to check for
// it.
{ return isSep(toks, TT.EMPTY); }
// Require either a line break or a given character (default ;)
static void reqSep(ref TokenArray toks, TT symbol = TT.Semicolon)
{
if(!isSep(toks, symbol))
fail("Expected '" ~ tokenList[symbol] ~ "' or newline", toks);
}
static void reqNext(ref TokenArray toks, TT type, out Token tok)
{
if(!isNext(toks, type, tok))
fail("Expected " ~ tokenList[type], toks);
}
static void reqNext(ref TokenArray toks, TT type, out Floc loc)
{
Token t;
reqNext(toks, type, t);
loc = t.loc;
}
static void reqNext(ref TokenArray toks, TT type)
{
Token t;
reqNext(toks, type, t);
}
// Skip any matching set of parens (), [] or {}, and anything inside
// it.
static void skipParens(ref TokenArray toks, TT type = TT.LeftParen)
{
TT endType;
if(type == TT.LeftParen)
endType = TT.RightParen;
else if(type == TT.LeftCurl)
endType = TT.RightCurl;
else if(type == TT.LeftSquare)
endType = TT.RightSquare;
else assert(0);
int count = 0;
while(toks.length != 0)
{
if(toks[0].type == type)
count++;
else if(toks[0].type == endType)
count--;
toks = toks[1..$];
if(count <= 0)
return;
}
}
// Sets the assembler debug line to the line belonging to this
// block.
final void setLine() { tasm.setLine(loc.line); }
public:
// File position where this block was defined
Floc loc;
// Parse a list of tokens and attempt to understand how they belong
// together. This is the syntactical level.
void parse(ref TokenArray toks);
// This goes through the code, resolves names and types etc,
// converts expressions into an intermediate form which can be
// compiled to byte code later. This is basically the semantic level.
void resolve(Scope sc);
}

656
old_d_version/monster/compiler/bytecode.d
Unescape Escape View File

@ -1,656 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (bytecode.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.bytecode;
// Byte code operands
enum BC
{
Exit = 1, // Exit function.
Call, // Call function in this object. Takes a
// global function index on the stack, int.
CallFar, // Call function in another object. The object
// must be pushed on the stack, followed by
// the global function index.
Return, // Takes a parameter nr (int). Equivalent to:
// POPN nr (remove nr values of the stack)
// EXIT
ReturnVal, // Takes parameter nr (int). Equivalent to:
// POP value and store it in TMP
// POPN nr (remove function parameters)
// PUSH TMP (put return value back on stack)
// EXIT
ReturnValN, // Same as ReturnVal, but takes a second
// parameter (int). This gives the size of the
// return value.
State, // Set state. Followed by an int giving the
// state index, another int giving the label
// index and a third int giving the class tree
// index. State index -1 means the empty
// state, and -1 for the label means no label
// is specified (eg state = test; instead of
// state = test.label). For state -1 the label
// index must also be -1, and the class index
// is ignored.
EnumValue, // Get the 'value' field of the enum variable
// on the stack. Takes an enum type index.
EnumField, // Get the given field of an enum. Takes the
// field number and the enum type index, both
// ints.
EnumValToIndex, // Used to look up enum names (string index)
EnumNameToIndex, // or value (long) and returns the enum index.
New, // Create a new object. Followed by an int
// giving the class index (in the file lookup
// table) and one giving the paramter
// number. The parameter indices, class
// indices and values are popped of the stack,
// see NewExpression.evalAsm for details.
Clone, // Clones an object - create a new object of
// the same class, then copy variable values
// and state from the old object to the
// new. Replaces the object index on the stack
// with the new index.
Jump, // Jump to given position (int)
JumpZ, // Pop a value, if it is zero then jump to
// given position (int)
JumpNZ, // Jump if non-zero
PushData, // Push the next four bytes verbatim
PushLocal, // Push value of a local variable or function
// parameter, index given as a signed
// int. Gives the index from the current stack
// frame. 0 is the first int, 1 is the second
// int, -1 is the last int in the function
// parameter area, etc.
PushClassVar, // Push value in object data segment (in this
// object). Parameter is an int offset.
PushParentVar, // Push value in data segment of parent
// object. int class tree index, int offset
PushFarClassVar, // Push value from the data segment in another
// object. The object reference is already on
// the stack. int class tree index, int offset
PushFarClassMulti, // Pushes multiple ints from the data
// segment. Takes the variable size (int) as
// the first parameter, otherwise identical to
// PushFarClassVar.
PushThis, // Push the 'this' object reference
PushSingleton, // Push the singleton object. Takes the global
// class index (int) as parameter.
// The Push*8 instructions are not implemented yet as they are
// just optimizations of existing features. The names are reserved
// for future use.
Push8, // Push the next 8 bytes (two ints)
// verbatim.
PushLocal8, // Does the same as PushLocal except it also
// pushes the next int onto the stack. The
// index must be > 0 or <= -2.
PushClassVar8, // Same as PushClassVar but pushes two ints
PushFarClassVar8,
Pop, // Pop data and forget about it
PopN, // Takes a byte parameter N, equivalent to
// calling Pop N times.
Dup, // Duplicate the next value on the
// stack. Equivalent to: a=pop; push a; push
// a;
Store, // Basic operation for moving data to
// memory. Schematically pops a Ptr of the
// stack, pops a value, moves the value into
// the Ptr.
Store8, // Same as Store except two ints are popped
// from the stack and moved into the data.
StoreMult, // Takes the size as an int parameter
IAdd, // Standard addition, operates on the two next
// ints in the stack, and stores the result in
// the stack.
ISub, // Subtraction. a-b, where a is pushed first.
IMul, // Multiplication
IDiv, // Division. The dividend must be pushed
// first, the divisor second.
UDiv, // uint
IDivRem, // Reminder division
UDivRem, // uint
INeg, // Negate the next integer on the stack
FAdd, // Float arithmetic
FSub,
FMul,
FDiv,
FIDiv,
FDivRem,
FNeg,
LAdd, // Long arithmetic
LSub,
LMul,
LDiv,
ULDiv,
LDivRem,
ULDivRem,
LNeg,
DAdd, // Double arithmetic
DSub,
DMul,
DDiv,
DIDiv,
DDivRem,
DNeg,
IsEqual, // Pop two ints, push true (1) if they are
// equal or false (0) otherwise
IsEqualMulti, // Takes an int parameter giving the value size
IsCaseEqual, // Same as IsEqual, but uses (unicode) case
// insensitive match. Values are assumed to be
// dchars.
CmpArray, // Compare two arrays. Only does exact
// byte-for-byte matching.
ICmpStr, // Does a case insensitive check of two
// strings. Both these pop two array indices
// of the stack and push a bool.
PreInc, // ++, pops an address, increases variable,
// and pushes the value
PreDec, // -- (these might change)
PostInc, // ++ and -- that push the original value
PostDec, // rather than the new one
PreInc8, PreDec8,
PostInc8, PostDec8, // 64 bit versions
Not, // Inverse the bool on the stack
ILess, // Pops b, pops a, pushes true if a < b, false
// otherwise. Works on signed ints.
ULess, // unsigned ints
LLess, // long
ULLess, // ulong
FLess, // float
DLess, // double
// All the Cast* instructions pops a variable of the given type of
// the stack, and pushes back an equivalent variable of the new
// type.
CastI2L, // int to long (signed)
CastD2F, // double to float
CastF2D, // float to double
CastI2F, // int to float
CastU2F, // uint to float
CastL2F, // long to float
CastUL2F, // ulong to float
CastI2D, // int to double
CastU2D, // uint to double
CastL2D, // long to double
CastUL2D, // ulong to double
CastF2I, // float to int
CastF2U, // float to uint
CastF2L, // float to long
CastF2UL, // float to ulong
CastD2I, // double to int
CastD2U, // double to uint
CastD2L, // double to long
CastD2UL, // double to ulong
CastS2C, // string to char - string must have length 1
CastT2S, // cast any type to string. Takes the type
// index (int) as a parameter
DownCast, // Takes a global class index (int). Checks if
// the object on the stack is an instance of
// the given class.
RefFunc, // Pop an array reference (two ints) and push
// the corresponding function name as a string
FetchElem, // Get an element from an array. Pops the
// index, then the array reference, then
// pushes the value. The element size is
// determined from the array.
GetArrLen, // Get the length of an array. Pops the array,
// pushes the length.
PopToArray, // Takes a raw length n (int) and an element
// size (int). Creates an array from the last
// n values on the stack and pops them off.
// Pushes the new array index. The values are
// copied into the new array, and are
// independent of the stack.
NewArray, // Takes one int giving the array nesting
// level (rank), one int giving the element
// size (s) and s ints giving the initial
// value. Pops the lengths (one int per rank
// level) from the stack. Pushes a new array
// of the given length. The lengths should
// pushed in the same order they appear in a
// new-expression, ie. new int[1][2] are
// pushed as 1 then 2.
CopyArray, // Pops two array indices from the stack, and
// copies the data from one to another. The
// destination array is popped first, then the
// source. The lengths must match. The arrays
// may overlap in memory without unexpected
// effects.
DupArray, // Pops an array index of the stack, creates a
// copy of the array, and pushes the index of
// the new array.
MakeConstArray, // Pops an array index, creates a const
// reference to the same data, pushes the
// index.
IsConstArray, // Pops the array index, pushes bool
// reflecting the const status
Slice, // Create a slice. Pops the second index, then
// the first, then the array index. Pushes a
// new array that is a slice of the original.
FillArray, // Fill an array. Pop an array index, then a
// value. Sets all the elements in the array
// to the value. Takes an int specifying the
// element/value size.
CatArray, // Concatinate two arrays, on the stack.
CatLeft, // Concatinate an array with a left
// element. The element is pushed first, so
// the array index is first off the stack.
CatRight, // Concatinate with right element. Array
// pushed first, then element. Both these take
// an element size (int).
ReverseArray, // Reverses an array. The index is on the
// stack. The array is reversed in place, and
// the index is left untouched on the stack.
CreateArrayIter, // Create array iterator. Expects the stack to
// hold an index(int), a value(int) and an
// array index, pushed in that order. Replaces
// the array index with an iterator index,
// sets the rest to reflect the first element
// in iteration. Takes two byte parameters
// that are either 0 or 1. If the first is
// set, then the array is iterated in the
// reverse order. If the second is set, then
// the value is a reference, ie. changes to it
// will be transfered back to the orignal
// array. Pushes false if the array is empty,
// true otherwise.
CreateClassIter, // Create a class iterator. Expects the
// stack to hold a value (object index =
// int). Takes one int parameter, which is the
// class index. Pushes false if no objects
// exist, true otherwise.
IterNext, // Iterate to the next element. Leaves the
// iteration variables on the stack. Pushes
// false if this was the last element, true
// otherwise.
IterBreak, // Break off iteration. Does exactly the same
// thing as IterNext would done if it had just
// finished the last iteration step, except it
// does not push anything onto the stack.
IterUpdate, // Update the original array or data from
// reference variables in this
// iteration. Called whenever a 'ref' variable
// is changed, to make sure that the changes
// take effect. Takes an int parameter that
// gives the stack position (in the current
// frame) of the iterator index.
GetStack, // Internal debugging function. Pushes the
// current stack position on the stack. Might
// be removed later.
MultiByte, // This instruction consists of a second byte
// or an extra int. Reserved for future
// use. This is intended for when / if the
// number of instructions exceeds
// 256. Instructions in this list with numbers
// >= 256 will be coded in this way.
// Instructions appearing after the MultiByte mark might be coded
// as multi-byte. They are handled in a more time-consuming
// matter. You should only use this space for instructions that
// are seldomly executed.
Error, // Throw an exception. Takes an error code
// (byte) defined below. The library user will
// later be able to choose whether this halts
// execution entirely or just kills the
// offending vthread.
Last
}
// Make sure all single-byte instructions will in fact fit in a single
// byte.
static assert(BC.MultiByte < 255);
// Make us aware when we break the byte barrier
static assert(BC.Last < 255);
enum Err
{
None, // Should never happen
NoReturn, // Function is missing a return statement
}
// Used for coded pointers. The first byte in a coded pointer gives
// the pointer type, and the remaining 24 bits gives an index whose
// meaning is determined by the type. The pointers can be used both
// for variables and for functions. All pointers are 3 ints in size on
// the stack. The comments below defines what the indices mean - the
// ones that are not mentioned are zero.
enum PT
{
Null = 0, // Null pointer. The index must also be zero.
Stack = 1, // Index is relative to function stack
// frame. Used for local variables.
DataOffs = 2, // This class, this object. Index is data
// segment offset.
DataOffsCls = 4, // Variable is in this object, but in another
// class. The class MUST be a parent class of the
// current object. A class tree index follows
// this pointer on the stack.
FarDataOffs = 5, // Another class, another object. The index is a
// data offset. Pop the class index off the
// stack, and then object index.
ArrayIndex = 30, // Pointer to an array element. The array and
// the index are pushed on the stack, the
// pointer index is zero.
}
char[] errorString(ubyte er)
{
if(er < errorToString.length)
return errorToString[er];
return "Unknown error code";
}
union _CodePtr
{
// How the pointer is coded
align(1) struct
{
ubyte type;
int val24;
}
// The end result is stored in val32
align(1) struct
{
int val32;
ubyte remains;
}
}
static assert(_CodePtr.sizeof == 5);
// Encode a "pointer". Pointers are two shorts encoded into an
// int. The first byte is the pointer type, the remaining 24 bits
// gives the index.
int codePtr(PT type, int index)
{
assert(index >= -(1<<23) && index < (1<<24),
"index out of range for 24 bit value");
assert(type != 0 || index == 0,
"null pointers must have index == 0");
assert(type == PT.Stack || index >= 0,
"only PT.Stack can have a negative index");
_CodePtr t;
t.type = type;
t.val24 = index;
assert((index >= 0 && t.remains == 0) ||
(index < 0 && t.remains == 255));
return t.val32;
}
void decodePtr(int ptr, out PT type, out int index)
{
_CodePtr t;
t.val32 = ptr;
// Manage negative numbers
if(t.val24 >= 0x800000)
{
t.remains = 255;
assert(t.val24 < 0);
}
type = cast(PT) t.type;
index = t.val24;
assert(type != 0 || index == 0,
"null pointers must have index == 0");
}
// Getting the name of an enum should be much easier than creating
// braindead constructions like this. Although this is still much
// better than the C++ equivalent. I'm just happy I did it through a
// script instead of typing it all by hand.
// These kind of braindead constructions will luckily be completely
// unnecessary in Monster script, We will not only will have .name
// property on enums, but make it easy to assign other values (like
// numbers and descriptions) to them as well.
char[][] errorToString =
[
Err.None: "No error!",
Err.NoReturn: "Function ended without returning a value"
];
char[][] bcToString =
[
BC.Exit: "Exit",
BC.Call: "Call",
BC.CallFar: "CallFar",
BC.Return: "Return",
BC.ReturnVal: "ReturnVal",
BC.ReturnValN: "ReturnValN",
BC.State: "State",
BC.EnumValue: "EnumValue",
BC.EnumField: "EnumField",
BC.EnumValToIndex: "EnumValToIndex",
BC.EnumNameToIndex: "EnumNameToIndex",
BC.New: "New",
BC.Jump: "Jump",
BC.JumpZ: "JumpZ",
BC.JumpNZ: "JumpNZ",
BC.PushData: "PushData",
BC.PushLocal: "PushLocal",
BC.PushClassVar: "PushClassVar",
BC.PushParentVar: "PushParentVar",
BC.PushFarClassVar: "PushFarClassVar",
BC.PushFarClassMulti: "PushFarClassMulti",
BC.PushThis: "PushThis",
BC.PushSingleton: "PushSingleton",
BC.Push8: "Push8",
BC.PushLocal8: "PushLocal8",
BC.PushClassVar8: "PushClassVar8",
BC.PushFarClassVar8: "PushFarClassVar8",
BC.Pop: "Pop",
BC.PopN: "PopN",
BC.Dup: "Dup",
BC.Store: "Store",
BC.Store8: "Store8",
BC.StoreMult: "StoreMult",
BC.RefFunc: "RefFunc",
BC.FetchElem: "FetchElem",
BC.GetArrLen: "GetArrLen",
BC.IMul: "IMul",
BC.IAdd: "IAdd",
BC.ISub: "ISub",
BC.IDiv: "IDiv",
BC.IDivRem: "IDivRem",
BC.UDiv: "UDiv",
BC.UDivRem: "UDivRem",
BC.INeg: "INeg",
BC.LMul: "LMul",
BC.LAdd: "LAdd",
BC.LSub: "LSub",
BC.LDiv: "LDiv",
BC.LDivRem: "LDivRem",
BC.ULDiv: "ULDiv",
BC.ULDivRem: "ULDivRem",
BC.LNeg: "LNeg",
BC.DMul: "DMul",
BC.DAdd: "DAdd",
BC.DSub: "DSub",
BC.DDiv: "DDiv",
BC.DIDiv: "DIDiv",
BC.DDivRem: "DDivRem",
BC.DNeg: "DNeg",
BC.FAdd: "FAdd",
BC.FSub: "FSub",
BC.FMul: "FMul",
BC.FDiv: "FDiv",
BC.FIDiv: "FIDiv",
BC.FDivRem: "FDivRem",
BC.FNeg: "FNeg",
BC.IsEqual: "IsEqual",
BC.IsEqualMulti: "IsEqualMulti",
BC.IsCaseEqual: "IsCaseEqual",
BC.CmpArray: "CmpArray",
BC.ICmpStr: "ICmpStr",
BC.PreInc: "PreInc",
BC.PreDec: "PreDec",
BC.PostInc: "PostInc",
BC.PostDec: "PostDec",
BC.PreInc8: "PreInc8",
BC.PreDec8: "PreDec8",
BC.PostInc8: "PostInc8",
BC.PostDec8: "PostDec8",
BC.Not: "Not",
BC.ILess: "ILess",
BC.ULess: "ULess",
BC.LLess: "LLess",
BC.ULLess: "ULLess",
BC.FLess: "FLess",
BC.DLess: "DLess",
BC.CastI2L: "CastI2L",
BC.CastI2F: "CastI2F",
BC.CastU2F: "CastU2F",
BC.CastL2F: "CastL2F",
BC.CastUL2F: "CastUL2F",
BC.CastD2F: "CastD2F",
BC.CastI2D: "CastI2D",
BC.CastU2D: "CastU2D",
BC.CastL2D: "CastL2D",
BC.CastUL2D: "CastUL2D",
BC.CastF2D: "CastF2D",
BC.CastF2I: "CastF2I",
BC.CastF2U: "CastF2U",
BC.CastF2L: "CastF2L",
BC.CastF2UL: "CastF2UL",
BC.CastD2I: "CastD2I",
BC.CastD2U: "CastD2U",
BC.CastD2L: "CastD2L",
BC.CastD2UL: "CastD2UL",
BC.CastS2C: "CastS2C",
BC.CastT2S: "CastT2S",
BC.DownCast: "DownCast",
BC.PopToArray: "PopToArray",
BC.NewArray: "NewArray",
BC.CopyArray: "CopyArray",
BC.DupArray: "DupArray",
BC.MakeConstArray: "MakeConstArray",
BC.IsConstArray: "IsConstArray",
BC.Slice: "Slice",
BC.FillArray: "FillArray",
BC.CatArray: "CatArray",
BC.CatLeft: "CatLeft",
BC.CatRight: "CatRight",
BC.CreateArrayIter: "CreateArrayIter",
BC.IterNext: "IterNext",
BC.IterBreak: "IterBreak",
BC.IterUpdate: "IterUpdate",
BC.CreateClassIter: "CreateClassIter",
BC.GetStack: "GetStack",
BC.MultiByte: "MultiByte",
BC.Error: "Error",
];

133
old_d_version/monster/compiler/enums.d
Unescape Escape View File

@ -1,133 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (enums.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.enums;
import monster.compiler.scopes;
import monster.compiler.types;
import monster.compiler.expression;
import monster.compiler.statement;
import monster.compiler.tokenizer;
import monster.vm.error;
// Definition of a field
struct FieldDef
{
Token name;
Type type;
}
// Definition of each entry in the enum
struct EnumEntry
{
Token name; // Entry identifier
int index; // Enum index value
char[] stringValue; // Returned when printing the value
long value; // Numeric value assigned to the enum. Can be set by the
// user, but defaults to 0 for the first entry and to
// the previous entry+1 when no value is set.
Expression exp[]; // Field values (before resolving)
int[][] fields; // Field values
}
class EnumDeclaration : TypeDeclaration
{
static bool canParse(TokenArray toks)
{ return toks.isNext(TT.Enum); }
EnumType type;
override:
void parse(ref TokenArray toks)
{
type = new EnumType();
reqNext(toks, TT.Enum);
reqNext(toks, TT.Identifier, type.nameTok);
// Field definitions?
while(isNext(toks, TT.Colon))
{
FieldDef fd;
fd.type = Type.identify(toks);
reqNext(toks, TT.Identifier, fd.name);
type.fields ~= fd;
}
reqNext(toks, TT.LeftCurl);
type.name = type.nameTok.str;
type.loc = type.nameTok.loc;
// Parse the entries and their fields
int lastVal = -1;
while(!isNext(toks, TT.RightCurl))
{
EnumEntry entry;
reqNext(toks, TT.Identifier, entry.name);
// Get the given value, if any
if(isNext(toks, TT.Equals))
{
Token num;
reqNext(toks, TT.IntLiteral, num);
lastVal = LiteralExpr.parseIntLiteral(num);
}
else
// No given value, just increase the last one given
lastVal++;
entry.value = lastVal;
while(isNext(toks, TT.Colon))
entry.exp ~= Expression.identify(toks);
reqSep(toks, TT.Comma);
type.entries ~= entry;
}
if(type.entries.length == 0)
fail("Enum is empty", type.loc);
isNext(toks, TT.Semicolon);
}
void insertType(TFVScope last)
{
// Insert ourselves into the parent scope
assert(last !is null);
assert(type !is null);
last.insertEnum(type);
}
void resolve(Scope last)
{
// Delegate to the type, since all the variables are defined
// there.
type.resolve(last);
}
}

1393
old_d_version/monster/compiler/expression.d
View File

File diff suppressed because it is too large Load Diff

1464
old_d_version/monster/compiler/functions.d
View File

File diff suppressed because it is too large Load Diff

74
old_d_version/monster/compiler/linespec.d
Unescape Escape View File

@ -1,74 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (linespec.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
/* This module provides a simple system for converting positions in a
code segment (of compiled byte code) into a line number in source
code.
*/
module monster.compiler.linespec;
import monster.vm.error;
// A line specification. These are usually found in a list, one for
// each buffer of code. All instructions after position 'pos' belong
// to line 'line', unless a new LineSpec comes after it that covers
// that position.
struct LineSpec
{
int pos; // Offset of instruction
int line; // Line number for instructions after this offset
}
// Find the line belonging to a given position. This does not need to
// be fast, it is only used for error messages and the like.
int findLine(LineSpec[] list, int pos)
{
int lastpos = -1;
int lastline = -1;
assert(pos >= 0);
// The first entry must represent pos = 0
if(list.length && list[0].pos != 0)
fail("Invalid line list: first offset not zero");
foreach(ls; list)
{
if(ls.pos <= lastpos)
fail("Invalid line list: decreasing offset");
// Have we searched past pos?
if(ls.pos > pos)
// If so, the last entry was the correct one
return lastline;
lastpos = ls.pos;
lastline = ls.line;
}
// We never searched past our position, that means the last entry is
// the most correct.
return lastline;
}

1150
old_d_version/monster/compiler/operators.d
View File

File diff suppressed because it is too large Load Diff

377
old_d_version/monster/compiler/properties.d
Unescape Escape View File

@ -1,377 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (properties.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.properties;
import monster.compiler.scopes;
import monster.compiler.types;
import monster.compiler.assembler;
import monster.vm.mclass;
import std.stdio;
/* This module contains special scopes for builtin types. These are
used to resolve type properties like .length for arrays and .min
and .max for ints, etc.
*/
// TODO: This is nice, but could be nicer. I would like most of these
// stored as values rather than functions, and have a general
// mechanism for converting values into data (a converted version of
// pushInit in Type) used for all types except the ones requiring a
// function. I guess I could make versions of insert(s) that takes
// floats, ints etc as parameters, and double checks it against the
// type. The main reason for storing values is that most of them can
// then be optimized away as compile time constants. This is not a
// priority.
class NumericProperties(T) : SimplePropertyScope
{
this()
{
super(T.stringof ~ "Properties",
GenericProperties.singleton);
// Static properties of all numeric types
static if(T.sizeof == 4)
{
inserts("min", T.stringof, { tasm.push(T.min); });
inserts("max", T.stringof, { tasm.push(T.max); });
}
else static if(T.sizeof == 8)
{
inserts("min", T.stringof, { tasm.push8(T.min); });
inserts("max", T.stringof, { tasm.push8(T.max); });
}
else static assert(0);
}
}
class IntProperties : NumericProperties!(int)
{ static IntProperties singleton; }
class UintProperties : NumericProperties!(uint)
{ static UintProperties singleton; }
class LongProperties : NumericProperties!(long)
{ static LongProperties singleton; }
class UlongProperties : NumericProperties!(ulong)
{ static UlongProperties singleton; }
class FloatingProperties(T) : NumericProperties!(T)
{
this()
{
char[] tp = T.stringof;
// Additional static properties of floating point numbers
static if(T.sizeof == 4)
{
inserts("infinity", tp, { tasm.push(T.infinity); });
inserts("inf", tp, { tasm.push(T.infinity); });
inserts("nan", tp, { tasm.push(T.nan); });
inserts("epsilon", tp, { tasm.push(T.epsilon); });
}
else static if(T.sizeof == 8)
{
inserts("infinity", tp, { tasm.push8(T.infinity); });
inserts("inf", tp, { tasm.push8(T.infinity); });
inserts("nan", tp, { tasm.push8(T.nan); });
inserts("epsilon", tp, { tasm.push8(T.epsilon); });
}
else static assert(0);
inserts("dig", "int", { tasm.push(T.dig); });
inserts("max_10_exp", "int", { tasm.push(T.max_10_exp); });
inserts("max_exp", "int", { tasm.push(T.max_exp); });
inserts("min_10_exp", "int", { tasm.push(T.min_10_exp); });
inserts("min_exp", "int", { tasm.push(T.min_exp); });
// Number of bits in mantissa. D calls it mant_dig, but
// mant_bits is more natural. Let us allow both.
inserts("mant_bits", "int", { tasm.push(T.mant_dig); });
inserts("mant_dig", "int", { tasm.push(T.mant_dig); });
// Lets add in number of bits in the exponent as well.
inserts("exp_bits", "int", { tasm.push(cast(uint)(8*T.sizeof-T.mant_dig)); });
}
}
class FloatProperties : FloatingProperties!(float)
{ static FloatProperties singleton; }
class DoubleProperties : FloatingProperties!(double)
{ static DoubleProperties singleton; }
// Function pointers / references
class FuncRefProperties : SimplePropertyScope
{
static FuncRefProperties singleton;
this()
{
super("FuncRefProperties", GenericProperties.singleton);
// A function ref is object + function index. Just pop away the
// function and the object is left on the stack. Since we cannot
// possibly know the type of the object at compile time, we
// default to 'Object' as the class type.
auto ot = MonsterClass.getObject().objType;
assert(ot !is null);
insert("obj", ot, { tasm.pop(); });
// TODO: Replace this with something else later (like a Function
// class or similar)
insert("func", ArrayType.getString(), { tasm.refFunc(); });
}
}
// Handles .length, .dup, etc for arrays
class ArrayProperties: SimplePropertyScope
{
static ArrayProperties singleton;
this()
{
super("ArrayProperties", GenericProperties.singleton);
insert("length", "int",
{ tasm.getArrayLength(); },
{ assert(0, "cannot set length yet"); });
insert("dup", "owner", { tasm.dupArray(); });
insert("reverse", "owner", { tasm.reverseArray(); });
insert("sort", "owner", { assert(0, "sort not implemented"); });
insert("const", "owner", { tasm.makeArrayConst(); });
insert("isConst", "bool", { tasm.isArrayConst(); });
}
}
// TODO: Rename to ObjectProperties
class ClassProperties : SimplePropertyScope
{
static ClassProperties singleton;
this()
{
super("ClassProperties",
GenericProperties.singleton);
insert("clone", "owner", { tasm.cloneObj(); });
// We should move handling of states here. This will mean
// removing StateStatement and making states a propert type. We
// can't leave statestatement in as a special syntax for setting
// types, because the member syntax obj.state = state.label;
// would still have to be handled somehow. However, even if this
// is more work, it has some additional benefits of allowing
// states to be used in other expressions, eg state ==
// SomeState. And we should still be able to optimize it into
// one instruction.
// One downside now is that we are currently using static
// properties. If we are going to use non-static properties and
// allow both member and non-member access, we have to
// differentiate between near and far properties too. Think more
// about it.
//insert("state", "int", { tasm.push(6); });
}
}
// Dynamically handles properties like init and sizeof that are valid
// for all types.
class GenericProperties : SimplePropertyScope
{
static GenericProperties singleton;
this()
{
super("GenericProperties");
inserts("init", "owner", {assert(0);});
inserts("sizeof", "int", {assert(0);});
inserts("bitsof", "int", {assert(0);});
}
// Overwrite the above actions
void getValue(char[] name, Type oType)
{
if(oType.isMeta) oType = oType.getBase();
if(name == "sizeof") tasm.push(oType.getSize);
else if(name == "bitsof") tasm.push(oType.getSize*32);
else if(name == "init") oType.pushInit();
else assert(0);
}
}
/* This is a base class that simplifies definition of property
scopes. You can simply call insert and inserts (for static
properties) in the constructor. An example:
inserts("max", "int", { tasm.push(int.max); });
This inserts the property "max", of type "int", and pushes the
value int.max whenever it is invoked. Since it is a static
property, the left hand side (eg an int value) is never
evaluated. If the type is "" or "owner", then the property type
will be the same as the owner type.
It's likely that parts of this will be simplified or rewritten
later. One thing that's missing is compile time properties, for
example.
*/
abstract class SimplePropertyScope : PropertyScope
{
this(char[] n, PropertyScope ps = null) { super(n, ps); }
private SP[char[]] propList;
// Convert a typename to a type
private Type getType(char[] tp)
{
if(tp == "" || tp == "owner")
return null;
return BasicType.get(tp);
}
// Insert properties into the list
void insert(char[] name, Type tp, Action push, Action pop = null)
{
assert(!hasProperty(name));
propList[name] = SP(tp, false, push, pop);
}
void insert(char[] name, char[] tp, Action push, Action pop = null)
{ insert(name, getType(tp), push, pop); }
// Insert static properties. TODO: These should take values rather
// than code. It should be possible to retireve this value at
// compile-time.
void inserts(char[] name, Type tp, Action push)
{
assert(!hasProperty(name));
propList[name] = SP(tp, true, push, null);
}
void inserts(char[] name, char[] tp, Action push)
{ inserts(name, getType(tp), push); }
// TODO: These are hacks to work around a silly but irritating DMD
// feature. Whenever there's an error somewhere, function literals
// like { something; } get resolved as int delegate() instead of
// void delegate() for some reason. This gives a ton of error
// messages, but these overloads will prevent that.
alias int delegate() FakeIt;
void insert(char[],char[],FakeIt,FakeIt pop = null) {assert(0);}
void insert(char[],Type,FakeIt,FakeIt pop = null) {assert(0);}
void inserts(char[],char[],FakeIt) {assert(0);}
void inserts(char[],Type,FakeIt) {assert(0);}
override:
// Return the stored type. If it is null, return the owner type
// instead.
Type getType(char[] name, Type oType)
{
assert(hasProperty(name));
Type tp = propList[name].type;
// No stored type? We have to copy the owner.
if(tp is null)
{
// The owner type might be a meta-type (eg. int.init). Pretend
// it is the base type instead.
if(oType.isMeta())
tp = oType.getBase();
else
tp = oType;
}
return tp;
}
void getValue(char[] name, Type oType)
{
assert(hasProperty(name));
propList[name].push();
}
void setValue(char[] name, Type oType)
{
assert(hasProperty(name));
propList[name].pop();
}
bool hasProperty(char[] name)
{ return (name in propList) != null; }
bool isStatic(char[] name, Type oType)
{
assert(hasProperty(name));
return propList[name].isStatic;
}
bool isLValue(char[] name, Type oType)
{
assert(hasProperty(name));
return propList[name].isLValue();
}
}
alias void delegate() Action;
struct SP
{
Action push, pop;
Type type;
bool isStatic;
static SP opCall(Type tp, bool stat, Action push, Action pop)
{
SP s;
s.push = push;
s.pop = pop;
s.type = tp;
s.isStatic = stat;
assert(!stat || pop == null);
return s;
}
bool isLValue() { return pop != null; }
}
void initProperties()
{
GenericProperties.singleton = new GenericProperties;
ArrayProperties.singleton = new ArrayProperties;
IntProperties.singleton = new IntProperties;
UintProperties.singleton = new UintProperties;
LongProperties.singleton = new LongProperties;
UlongProperties.singleton = new UlongProperties;
FloatProperties.singleton = new FloatProperties;
DoubleProperties.singleton = new DoubleProperties;
ClassProperties.singleton = new ClassProperties;
FuncRefProperties.singleton = new FuncRefProperties;
}

1422
old_d_version/monster/compiler/scopes.d
View File

File diff suppressed because it is too large Load Diff

1607
old_d_version/monster/compiler/statement.d
View File

File diff suppressed because it is too large Load Diff

262
old_d_version/monster/compiler/states.d
Unescape Escape View File

@ -1,262 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (states.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.states;
import monster.compiler.scopes;
import monster.compiler.assembler;
import monster.compiler.tokenizer;
import monster.compiler.linespec;
import monster.compiler.statement;
import monster.vm.mclass;
import monster.vm.error;
import monster.util.aa;
import std.stdio;
struct State
{
MonsterClass owner; // This must be the first entry, since we're
// using some pointer trickery with Function and
// State.
LineSpec[] lines; // Line specifications for byte code
ubyte[] bcode; // Final compiled code
Token name;
int index;
// Labels in this scope.
HashTable!(char[], StateLabel*) labels;
StateLabel* labelList[];
// Cache the begin label since it has special meaning and is looked
// up often.
StateLabel* begin;
StateScope sc; // Scope for this state
// State declaration - used to resolve forward references. Should
// not be kept around when compilation is finished.
StateDeclaration stateDec;
StateLabel* findLabel(char[] name)
{
StateLabel *lb;
if(labels.inList(name, lb))
return lb;
return null;
}
// Look up a label in this state, or register a forward reference if
// the state hasn't been resolved yet.
void registerGoto(char[] label, LabelUser lu)
{
StateLabel *sl;
assert(lu !is null);
if( labels.inList(label, sl) )
lu.setLabel(sl.ls);
else
{
if(stateDec is null)
{
// The state has been resolved, and the label was not
// found. Let lu handle the error message.
lu.setLabel(null);
assert(0);
}
with(stateDec)
{
// The state is not resolved yet, so create a forward
// reference to this label.
Forward *fw;
// Get the pointer to the Forward struct in the AA, or a
// new one if none existed.
forwards.insertEdit(label, fw);
// Add the reference to the list
fw.lus ~= lu;
}
}
}
}
struct StateLabel
{
Token name;
uint offs;
uint index; // Index used to represent this label in byte code
LabelStatement ls; // TODO: Remove this later?
}
// Simple struct used for representing a label and its state in one
// value.
struct StateLabelPair
{
State *state;
StateLabel *label;
}
// Handles declaration of states at the class scope. Uses a code block
// for state contents.
class StateDeclaration : Statement
{
State *st;
CodeBlock code;
static struct Forward
{ LabelUser lus[]; }
HashTable!(char[], Forward) forwards;
static bool canParse(TokenArray toks)
{
return isNext(toks, TT.State);
}
void parse(ref TokenArray toks)
{
st = new State;
st.stateDec = this;
if(!isNext(toks, TT.State))
assert(0, "Internal error in StateDeclaration");
if(!isNext(toks, TT.Identifier, st.name))
fail("Expected state name identifier", toks);
// Create a code block, and tell it (the parameter) that it is a
// state block.
code = new CodeBlock(true);
code.parse(toks);
}
// Resolve the state. Besides resolving the code we have to resolve
// any forward references to labels within the state afterwards.
void resolve(Scope last)
{
assert(st !is null);
// Create a state scope. The scope will help enforce special
// rules, such as allowing idle functions and disallowing
// variable declarations.
st.sc = new StateScope(last, st);
st.owner = st.sc.getClass();
// Resolve the interior of the code block
assert(code !is null);
code.resolve(st.sc);
// Go through the forward list and resolve everything
foreach(char[] label, Forward fd; forwards)
{
StateLabel *sl;
LabelStatement ls;
if(st.labels.inList(label, sl))
{
assert(sl !is null);
ls = sl.ls;
}
else
ls = null; // Give a null to setLabel and let it handle
// the error message.
// Loop through the label users
foreach(LabelUser lu; fd.lus)
lu.setLabel(ls);
// setLabel should have thrown an error at this point
assert(ls !is null);
}
// Clear the forwards list
forwards.reset();
// At this point the State no longer needs to refer to us. Set
// the stateDec reference to null. This is also a signal to
// State.registerGoto that the state has been resolved, and no
// further forward references will be accepted.
st.stateDec = null;
// After the code has been resolved, all labels should now be
// registered in the 'labels' list. We must assign a number to
// each label for later reference. We also set up the labelList
// which can be used to look up the labels directly.
int cnt = 0;
st.labelList.length = st.labels.length;
foreach(char[] name, StateLabel *sl; st.labels)
{
assert(sl !is null);
assert(name == sl.name.str, "label name mismatch");
sl.index = cnt++;
st.labelList[sl.index] = sl;
// Cache the 'begin:' label
if(name == "begin")
{
assert(st.begin is null);
st.begin = sl;
}
}
}
// Compile it as a function.
void compile()
{
// No forward references must be inserted after the state has
// been resolved.
assert(forwards.length == 0);
tasm.newFunc();
code.compile();
// Table used to fetch the offset for the labels in this state.
uint offsets[];
offsets.length = st.labels.length;
// Assemble the code and get the offsets
st.bcode = tasm.assemble(st.lines, offsets);
// Store the offsets in the label statements themselves, for
// later use
int cnt = 0;
foreach(StateLabel* ls; st.labels)
{
ls.offs = offsets[ls.index];
}
}
char[] toString()
{
return
"State declaration: " ~
st.name.str ~ "\n" ~
code.toString();
}
}

167
old_d_version/monster/compiler/structs.d
Unescape Escape View File

@ -1,167 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (structs.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.structs;
import monster.compiler.types;
import monster.compiler.scopes;
import monster.compiler.variables;
import monster.compiler.functions;
import monster.compiler.tokenizer;
import monster.compiler.statement;
import monster.vm.error;
import std.stdio;
class StructDeclaration : TypeDeclaration
{
StructType type;
Token name;
private:
FuncDeclaration[] funcdecs;
VarDeclStatement[] vardecs;
// Identify what kind of block the given set of tokens represent,
// parse them, and store it in the appropriate list;
void store(ref TokenArray toks)
{
// canParse() is not ment as a complete syntax test, only to be
// enough to identify which Block parser to apply.
if(FuncDeclaration.canParse(toks))
{
auto fd = new FuncDeclaration;
funcdecs ~= fd;
fd.parse(toks);
}
else if(VarDeclStatement.canParse(toks))
{
auto vd = new VarDeclStatement;
vd.parse(toks);
vardecs ~= vd;
}
else
fail("Illegal type or declaration", toks);
}
public:
static bool canParse(TokenArray toks)
{ return toks.isNext(TT.Struct); }
override:
void parse(ref TokenArray toks)
{
if(!isNext(toks, TT.Struct, loc))
fail("Internal error in StructDeclaration");
if(!isNext(toks, TT.Identifier, name))
fail("Expected struct name", toks);
if(!isNext(toks, TT.LeftCurl))
fail("Struct expected {", toks);
// Parse the rest of the file
while(!isNext(toks, TT.RightCurl))
store(toks);
// Allow an optional semicolon
isNext(toks, TT.Semicolon);
}
void insertType(TFVScope last)
{
// Set up the struct type.
type = new StructType(this);
// Create a new scope
type.sc = new StructScope(last, type);
// Insert ourselves into the parent scope
assert(last !is null);
last.insertStruct(this);
}
void resolve(Scope last)
{
if(type.set)
return;
// Get the total number of variables.
uint tot = 0;
foreach(dec; vardecs)
tot += dec.vars.length;
// Must have at least one variable per declaration statement
assert(tot >= vardecs.length);
// Get one array containing all the variables
Variable*[] vars = new Variable*[tot];
int ind = 0;
foreach(st; vardecs)
foreach(dec; st.vars)
vars[ind++] = dec.var;
assert(ind == tot);
// Store the variables in the StructType
type.vars = vars;
// Mark the size as "set" now.
type.set = true;
// Resolve
foreach(dec; vardecs)
dec.resolve(type.sc);
// Calculate the struct size
type.size = 0;
foreach(t; vars)
type.size += t.type.getSize();
// Set up the init value
ind = 0;
int[] init = new int[type.getSize()];
foreach(st; vardecs)
foreach(dec; st.vars)
{
int si = dec.var.type.getSize();
init[ind..ind+si] = dec.getCTimeValue();
ind += si;
}
assert(ind == init.length);
type.defInit = init;
// Functions:
// Disallow anything but normal functions (we can fix static and
// native struct functions later.)
// Struct resolve only resolves header information, it doesn't
// resolve function bodies.
assert(funcdecs.length == 0, "struct functions not supported yet");
/*
foreach(dec; funcdecs)
type.sc.insertFunc(dec);
*/
}
}

942
old_d_version/monster/compiler/tokenizer.d
Unescape Escape View File

@ -1,942 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (tokenizer.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.compiler.tokenizer;
import std.string;
import std.stream;
import std.stdio;
import std.utf;
import monster.util.string : begins;
import monster.vm.error;
import monster.options;
alias Token[] TokenArray;
// Check if a character is alpha-numerical or an underscore
bool validIdentChar(char c)
{
if(validFirstIdentChar(c) || numericalChar(c))
return true;
return false;
}
// Same as above, except numbers are not allowed as the first
// character. Will extend to support full Unicode later.
bool validFirstIdentChar(char c)
{
if((c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z') ||
(c == '_') ) return true;
return false;
}
bool isValidIdent(char[] iname)
{
if(iname.length == 0)
return false;
if(!validFirstIdentChar(iname[0]))
return false;
foreach(char c; iname)
if(!validIdentChar(c)) return false;
return true;
}
bool numericalChar(char c)
{
return c >= '0' && c <= '9';
}
enum TT
{
// Syntax characters
Semicolon, DDDot, DDot,
LeftParen, RightParen,
LeftCurl, RightCurl,
LeftSquare, RightSquare,
Dot, Comma, Colon,
// Array length symbol
Dollar,
// 'at' sign, @
Alpha,
// Conditional expressions
IsEqual, NotEqual,
IsCaseEqual, IsCaseEqual2,
NotCaseEqual, NotCaseEqual2,
Less, More,
LessEq, MoreEq,
And, Or, Not,
// Assignment operators.
Equals, PlusEq, MinusEq, MultEq, DivEq, RemEq, IDivEq,
CatEq,
// Pre- and postfix increment and decrement operators ++ --
PlusPlus, MinusMinus,
// Arithmetic operators
Plus, Minus, Mult, Div, Rem, IDiv,
Cat,
// Keywords. Note that we use Class as a separator below, so it
// must be first in this list. All operator tokens must occur
// before Class, and all keywords must come after Class.
Class, Module, Singleton,
If, Else,
For, Foreach, ForeachRev,
Do, While, Until,
Continue, Break,
Typeof,
Return,
Switch, Select,
State,
Struct, Enum,
Import, Clone, Override, Final, Function, With,
This, New, Static, Const, Out, Ref, Abstract, Idle,
Public, Private, Protected, True, False, Native, Null,
Goto, Var,
Last, // Tokens after this do not have a specific string
// associated with them.
StringLiteral, // "something" or 'something'
IntLiteral, // Anything that starts with a number, except
// floats
FloatLiteral, // Any number which contains a period symbol
Identifier, // user-named identifier
EOF, // end of file
EMPTY // empty line (not stored)
}
struct Token
{
TT type;
char[] str;
Floc loc;
// Translated string literal (with resolved escape codes.)
dchar[] str32;
// True if this token was the first on its line.
bool newline;
char[] toString() { return str; }
static Token opCall(char[] name, Floc loc)
{ return Token(TT.Identifier, name, loc); }
static Token opCall(TT tt, char[] name, Floc loc)
{
Token t;
t.type = tt;
t.str = name;
t.loc = loc;
return t;
}
}
// Used to look up keywords.
TT keywordLookup[char[]];
bool lookupSetup = false;
void initTokenizer()
{
assert(!lookupSetup);
// Insert the keywords into the lookup table
for(TT t = TT.Class; t < TT.Last; t++)
{
char[] tok = tokenList[t];
assert(tok != "");
assert((tok in keywordLookup) == null);
keywordLookup[tok] = t;
}
lookupSetup = true;
}
// Index table of all the tokens
const char[][] tokenList =
[
TT.Semicolon : ";",
TT.DDDot : "...",
TT.DDot : "..",
TT.LeftParen : "(",
TT.RightParen : ")",
TT.LeftCurl : "{",
TT.RightCurl : "}",
TT.LeftSquare : "[",
TT.RightSquare : "]",
TT.Dot : ".",
TT.Comma : ",",
TT.Colon : ":",
TT.Dollar : "$",
TT.Alpha : "@",
TT.IsEqual : "==",
TT.NotEqual : "!=",
TT.IsCaseEqual : "=i=",
TT.IsCaseEqual2 : "=I=",
TT.NotCaseEqual : "!=i=",
TT.NotCaseEqual2 : "!=I=",
TT.Less : "<",
TT.More : ">",
TT.LessEq : "<=",
TT.MoreEq : ">=",
TT.And : "&&",
TT.Or : "||",
TT.Not : "!",
TT.Equals : "=",
TT.PlusEq : "+=",
TT.MinusEq : "-=",
TT.MultEq : "*=",
TT.DivEq : "/=",
TT.RemEq : "%=",
TT.IDivEq : "\\=",
TT.CatEq : "~=",
TT.PlusPlus : "++",
TT.MinusMinus : "--",
TT.Cat : "~",
TT.Plus : "+",
TT.Minus : "-",
TT.Mult : "*",
TT.Div : "/",
TT.Rem : "%",
TT.IDiv : "\\",
TT.Class : "class",
TT.Module : "module",
TT.Return : "return",
TT.For : "for",
TT.This : "this",
TT.New : "new",
TT.If : "if",
TT.Else : "else",
TT.Foreach : "foreach",
TT.ForeachRev : "foreach_reverse",
TT.Do : "do",
TT.While : "while",
TT.Until : "until",
TT.Continue : "continue",
TT.Break : "break",
TT.Switch : "switch",
TT.Select : "select",
TT.State : "state",
TT.Struct : "struct",
TT.Enum : "enum",
TT.Import : "import",
TT.Typeof : "typeof",
TT.Singleton : "singleton",
TT.Clone : "clone",
TT.Static : "static",
TT.Const : "const",
TT.Abstract : "abstract",
TT.Override : "override",
TT.Final : "final",
TT.Function : "function",
TT.With : "with",
TT.Idle : "idle",
TT.Out : "out",
TT.Ref : "ref",
TT.Public : "public",
TT.Private : "private",
TT.Protected : "protected",
TT.True : "true",
TT.False : "false",
TT.Native : "native",
TT.Null : "null",
TT.Goto : "goto",
TT.Var : "var",
// These are only used in error messages
TT.StringLiteral : "string literal",
TT.IntLiteral : "integer literal",
TT.FloatLiteral : "floating point literal",
TT.Identifier : "identifier",
TT.EOF : "end of file",
TT.EMPTY : "empty line - you should never see this"
];
class Tokenizer
{
private:
// Line buffer. Don't worry, this is perfectly safe. It is used by
// Stream.readLine, which uses the buffer if it fits and creates a
// new one if it doesn't. It is only here to optimize memory usage
// (avoid creating a new buffer for each line), and lines longer
// than 300 characters will work without problems.
char[300] buffer;
char[] line; // The rest of the current line
Stream inf;
int lineNum=-1;
char[] fname;
bool newline;
// Make a token of given type with given string, and remove it from
// the input line.
Token retToken(TT type, char[] str)
{
Token t;
t.type = type;
t.str = str;
t.newline = newline;
t.loc.fname = fname;
t.loc.line = lineNum;
// Special case for =I= and !=I=. Treat them the same as =i= and
// !=i=.
if(type == TT.IsCaseEqual2) t.type = TT.IsCaseEqual;
if(type == TT.NotCaseEqual2) t.type = TT.NotCaseEqual;
// Treat } as a separator
if(type == TT.RightCurl) t.newline = true;
// Remove the string from 'line', along with any following witespace
remWord(str);
return t;
}
// Removes 'str' from the beginning of 'line', or from
// line[leadIn..$] if leadIn != 0.
void remWord(char[] str, int leadIn = 0)
{
assert(line.length >= leadIn);
line = line[leadIn..$];
assert(line.begins(str));
line = line[str.length..$].stripl();
}
Token eofToken()
{
Token t;
t.str = "<end of file>";
t.type = TT.EOF;
t.newline = true;
t.loc.line = lineNum;
t.loc.fname = fname;
return t;
}
Token empty;
public:
final:
// Used when reading tokens from a file or a stream
this(char[] fname, Stream inf, int bom)
{
assert(inf !is null);
// The BOM (byte order mark) defines the byte order (little
// endian or big endian) and the encoding (utf8, utf16 or
// utf32).
switch(bom)
{
case -1:
// Files without a BOM are interpreted as UTF8
case BOM.UTF8:
// UTF8 is the default
break;
case BOM.UTF16LE:
case BOM.UTF16BE:
case BOM.UTF32LE:
case BOM.UTF32BE:
fail("UTF16 and UTF32 files are not supported yet");
default:
fail("Unknown BOM value!");
}
this.inf = inf;
this.fname = fname;
this();
}
// This is used for single-line mode, such as in a console.
this()
{
empty.type = TT.EMPTY;
}
void setLine(char[] ln)
{
assert(inf is null, "setLine only supported in line mode");
line = ln;
}
~this() { if(inf !is null) delete inf; }
void fail(char[] msg)
{
if(inf !is null)
// File mode
throw new MonsterException(format("%s:%s: %s", fname, lineNum, msg));
else
// Line mode
throw new MonsterException(msg);
}
// Various parsing modes
enum
{
Normal, // Normal mode
Block, // Block comment
Nest // Nested block comment
}
int mode = Normal;
int nests = 0; // Nest level
// Get the next token from the line, if any
Token getNextFromLine()
{
assert(lookupSetup,
"Internal error: The tokenizer lookup table has not been set up!");
restart:
if(mode == Block)
{
int index = line.find("*/");
// If we find a '*/', the comment is done
if(index != -1)
{
mode = Normal;
// Cut the comment from the input
remWord("*/", index);
}
else
{
// Comment was not terminated on this line, try the next
line = null;
}
}
else if(mode == Nest)
{
// Check for nested /+ and +/ in here, but go to restart if
// none is found (meaning the comment continues on the next
// line), or reset mode and go to restart if nest level ever
// gets to 0.
while(line.length >= 2)
{
int incInd = -1;
int decInd = -1;
// Find the first matching '/+' or '+/
foreach(int i, char c; line[0..$-1])
{
if(c == '/' && line[i+1] == '+')
{
incInd = i;
break;
}
else if(c == '+' && line[i+1] == '/')
{
decInd = i;
break;
}
}
// Add a nest level when '/+' is found
if(incInd != -1)
{
remWord("/+", incInd);
nests++;
continue; // Search more in this line
}
// Remove a nest level when '+/' is found
else if(decInd != -1)
{
// Remove the +/ from input
remWord("+/", decInd);
nests--; // Remove a level
assert(nests >= 0);
// Are we done? If so, return to normal mode.
if(nests == 0)
{
mode = Normal;
break;
}
continue;
}
// Nothing found on this line, try the next
break;
}
// If we're still in nested comment mode, ignore the rest of
// the line
if(mode == Nest)
line = null;
}
// Comment - ignore the rest of the line
if(line.begins("//"))
line = null;
// If the line is empty at this point, there's nothing more to
// be done
if(line == "")
return empty;
// Block comment
if(line.begins("/*"))
{
mode = Block;
line = line[2..$];
goto restart;
}
// Nested comment
if(line.begins("/+"))
{
mode = Nest;
line = line[2..$];
nests++;
goto restart;
}
if(line.begins("*/")) fail("Unexpected end of block comment");
if(line.begins("+/")) fail("Unexpected end of nested comment");
// String literals (multi-line literals not implemented yet)
if(line.begins("\"") || // Standard string: "abc"
line.begins("r\"") || // Wysiwig string: r"c:\dir"
line.begins("\\\"") || // ditto: \"c:\dir"
line.begins("'") ||
line.begins("r'") || // Equivalent ' versions
line.begins("\\'"))
{
bool found = false;
bool wysiwig = false;
// Quote character that terminates this string.
char quote;
char[] slice = line;
// Removes the first num chars from the line
void skip(int num)
{
assert(num <= line.length);
slice = slice[num..$];
}
// Parse the first quotation
if(slice[0] == '"' || slice[0] == '\'')
{
quote = slice[0];
skip(1);
}
else
{
// Check for wysiwig strings
if(slice[0] == '\\' || slice[0] == 'r')
wysiwig = true;
else assert(0);
quote = slice[1];
skip(2);
}
assert(quote == '"' || quote == '\'');
// This will store the result
dchar[] result;
// Stores a single character in the result string, and
// removes a given number of input characters.
void store(dchar ch, int slen)
{
result ~= ch;
skip(slen);
}
// Convert a given code into 'ch', if it is found.
void convert(char[] code, dchar ch)
{
if(slice.begins(code))
store(ch, code.length);
}
// Convert given escape character to 'res'
void escape(char ch, dchar res)
{
if(slice.length >= 2 &&
slice[0] == '\\' &&
slice[1] == ch)
store(res, 2);
}
// Interpret string
while(slice.length)
{
int startLen = slice.length;
// Convert "" to " (or '' to ' in single-quote strings)
convert(""~quote~quote, quote);
// Interpret backslash escape codes if we're not in
// wysiwig mode
if(!wysiwig)
{
escape('"', '"'); // \" == literal "
escape('\'', '\''); // \' == literal '
escape('\\', '\\'); // \\ == literal \
escape('a', 7); // \a == bell
escape('b', 8); // \b == backspace
escape('f', 12); // \f == feed form
escape('n', '\n'); // \n == newline
escape('r', '\r'); // \r == carriage return
escape('t', '\t'); // \t == tab
escape('v', '\v'); // \v == vertical tab
escape('e', 27); // \e == ANSI escape
// Check for numerical escapes
// If either of these aren't met, this isn't a valid
// escape code.
if(slice.length < 2 ||
slice[0] != '\\')
goto nocode;
// Checks and converts the digits in slice[] into a
// character.
void convertNumber(int skp, int maxLen, int base,
char[] pattern, char[] name)
{
assert(base <= 16);
// Skip backslash and other leading characters
skip(skp);
int len; // Number of digits found
uint result = 0;
for(len=0; len<maxLen; len++)
{
if(slice.length <= len) break;
char digit = slice[len];
// Does the digit qualify?
if(!inPattern(digit, pattern))
break;
// Multiply up the existing number to
// make room for the digit.
result *= base;
// Convert single digit to a number
if(digit >= '0' && digit <= '9')
digit -= '0';
else if(digit >= 'a' && digit <= 'z')
digit -= 'a' - 10;
else if(digit >= 'A' && digit <= 'Z')
digit -= 'A' - 10;
assert(digit >= 0 && digit < base);
// Add inn the digit
result += digit;
}
if(len > 0)
{
// We got something. Convert it and store
// it.
store(result, len);
}
else
fail("Invalid " ~ name ~ " escape code");
}
const Dec = "0-9";
const Oct = "0-7";
const Hex = "0-9a-fA-F";
// Octal escapes: \0N, \0NN or \0NNN where N are
// octal digits (0-7). Also accepts \o instead of
// \0.
if(slice[1] == '0' || slice[1] == 'o')
convertNumber(2, 3, 8, Oct, "octal");
// Decimal escapes: \N \NN and \NNN, where N are
// digits and the first digit is not zero.
else if(inPattern(slice[1], Dec))
convertNumber(1, 3, 10, Dec, "decimal");
// Hex escape codes: \xXX where X are hex digits
else if(slice[1] == 'x')
convertNumber(2, 2, 16, Hex, "hex");
// Unicode escape codes:
// \uXXXX
else if(slice[1] == 'u')
convertNumber(2, 4, 16, Hex, "Unicode hex");
// \UXXXXXXXX
else if(slice[1] == 'U')
convertNumber(2, 8, 16, Hex, "Unicode hex");
}
nocode:
// If something was converted this round, start again
// from the top.
if(startLen != slice.length)
continue;
assert(slice.length > 0);
// Nothing was done. Are we at the end of the string?
if(slice[0] == quote)
{
skip(1);
found = true;
break;
}
// Unhandled escape code?
if(slice[0] == '\\' && !wysiwig)
{
if(slice.length == 0)
// Just a single \ at the end of the line
fail("Multiline string literals not implemented");
else
fail("Unhandled escape code: \\" ~ slice[1]);
}
// Nope. It's just a normal character. Decode it from
// UTF8.
size_t clen = 0;
dchar cres;
cres = decode(slice,clen);
store(cres, clen);
}
if(!found) fail("Unterminated string literal '" ~line~ "'");
// Set 'slice' to contain the original string
slice = line[0..(line.length-slice.length)];
// Set up the token
auto t = retToken(TT.StringLiteral, slice.dup);
t.str32 = result;
return t;
}
// Numerical literals - if it starts with a number, we accept
// it, until it is interupted by an unacceptable character. We
// also accept numbers on the form .NUM. We do not try to parse
// the number here.
if(numericalChar(line[0]) ||
// Cover the .num case
( line.length >= 2 && line[0] == '.' &&
numericalChar(line[1]) ))
{
// Treat the rest as we would an identifier - the actual
// interpretation will be done later. We allow non-numerical
// tokens in the literal, such as 0x0a or 1_000_000. We must
// also explicitly allow '.' dots.
int len = 1;
bool lastDot = false; // Was the last char a '.'?
int dots; // Number of dots
foreach(char ch; line[1..$])
{
if(ch == '.')
{
// We accept "." but not "..", as this might be an
// operator.
if(lastDot)
{
// Remove the last dot and exit.
len--;
dots--;
break;
}
lastDot = true;
dots++;
}
else
{
if(!validIdentChar(ch)) break;
lastDot = false;
//lastPer = false;
}
// This was a valid character, count it
len++;
}
if(dots != 0)
return retToken(TT.FloatLiteral, line[0..len].dup);
else
return retToken(TT.IntLiteral, line[0..len].dup);
}
// Check for identifiers
if(validFirstIdentChar(line[0]))
{
// It's an identifier or name, find the length
int len = 1;
foreach(char ch; line[1..$])
{
if(!validIdentChar(ch)) break;
len++;
}
char[] id = line[0..len];
// We only allow certain identifiers to begin with __, as
// these are reserved for internal use.
if(id.begins("__"))
if(id != "__STACK__")
fail("Identifier " ~ id ~ " is not allowed to begin with __");
// Check if this is a keyword
if(id in keywordLookup)
{
TT t = keywordLookup[id];
assert(t >= TT.Class && t < TT.Last,
"Found " ~ id ~ " as a keyword, but with wrong type!");
return retToken(t, tokenList[t]);
}
// Not a keyword? Then it's an identifier
return retToken(TT.Identifier, id.dup);
}
// Check for operators and syntax characters. We browse through
// the entire list, and select the longest match that fits (so
// we don't risk matching "+" to "+=", for example.)
TT match;
int mlen = 0;
foreach(int i, char[] tok; tokenList[0..TT.Class])
{
// Skip =i= and family, if monster.options tells us to
static if(!ciStringOps)
{
if(i == TT.IsCaseEqual || i == TT.IsCaseEqual2 ||
i == TT.NotCaseEqual || i == TT.NotCaseEqual2)
continue;
}
if(line.begins(tok) && tok.length >= mlen)
{
assert(tok.length > mlen, "Two matching tokens of the same length");
mlen = tok.length;
match = cast(TT) i;
}
}
if(mlen) return retToken(match, tokenList[match]);
// Invalid token
fail("Invalid token " ~ line);
}
// Get the next token from a stream
Token getNext()
{
assert(inf !is null, "getNext() found a null stream");
if(lineNum == -1) lineNum = 0;
restart:
newline = false;
// Get the next line, if the current is empty
while(line.length == 0)
{
// No more information, we're done
if(inf.eof())
{
if(mode == Block) fail("Unterminated block comment");
if(mode == Nest) fail("Unterminated nested comment");
return eofToken();
}
// Read a line and remove leading and trailing whitespace
line = inf.readLine(buffer).strip();
lineNum++;
newline = true;
}
assert(line.length > 0);
static if(skipHashes)
{
// Skip the line if it begins with #.
if(/*lineNum == 1 && */line.begins("#"))
{
line = null;
goto restart;
}
}
Token tt = getNextFromLine();
// Skip empty lines, don't return them into the token list.
if(tt.type == TT.EMPTY)
goto restart;
return tt;
}
}
// Read the entire file into an array of tokens. This includes the EOF
// token at the end.
TokenArray tokenizeStream(char[] fname, Stream stream, int bom)
{
TokenArray tokenArray;
Tokenizer tok = new Tokenizer(fname, stream, bom);
Token tt;
do
{
tt = tok.getNext();
tokenArray ~= tt;
}
while(tt.type != TT.EOF)
delete tok;
return tokenArray;
}

2023
old_d_version/monster/compiler/types.d
View File

File diff suppressed because it is too large Load Diff

1132
old_d_version/monster/compiler/variables.d
View File

File diff suppressed because it is too large Load Diff

58
old_d_version/monster/modules/all.d
Unescape Escape View File

@ -1,58 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (all.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.modules.all;
import monster.modules.io;
import monster.modules.math;
import monster.modules.timer;
import monster.modules.frames;
import monster.modules.random;
import monster.modules.threads;
import monster.options;
bool has(char[] str, char[] sub)
{
if(sub.length == 0) return false;
int diff = str.length;
int sln = sub.length;
diff -= sln;
for(int i=0; i<=diff; i++)
if(str[i..i+sln] == sub[])
return true;
return false;
}
void initAllModules()
{
static if(moduleList.has("io")) initIOModule();
static if(moduleList.has("timer")) initTimerModule();
static if(moduleList.has("frames")) initFramesModule();
static if(moduleList.has("thread")) initThreadModule();
static if(moduleList.has("random")) initRandomModule();
static if(moduleList.has("math")) initMathModule();
}

553
old_d_version/monster/modules/console.d
Unescape Escape View File

@ -1,553 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (console.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.modules.console;
// This file implements an optimized way of running Monster
// interactively, what is sometimes called "line mode" or "interactive
// mode". It is ideally suited for making ingame consoles.
// The main idea is to retain all reusable data structures and
// minimize the number of heap allocations at runtime. The current
// implemention is not perfected in that regard, but later
// implementations will be.
// All input into the console is given through the input() function,
// and all output is sent to the output() callback function. You can
// also poll for output manually using output();
import monster.util.growarray;
import monster.compiler.tokenizer;
import monster.compiler.statement;
import monster.compiler.variables;
import monster.compiler.functions;
import monster.compiler.scopes;
import monster.compiler.bytecode;
import monster.compiler.assembler;
import monster.compiler.types;
import monster.compiler.expression;
import std.stdio;
import std.string;
import monster.monster;
// Console results
enum CR
{
Ok = 1, // Command was executed
Error = 2, // An error occurred
More = 3, // An unterminated multi-line statement was entered, need
// more input
Empty = 4, // The line was empty (nothing was executed)
}
class Console
{
private:
Tokenizer tn;
GrowArray!(Token) tokArr;
GrowArray!(char) outBuf;
Function fn;
FuncScope sc;
MonsterObject *obj;
Variable* varList[];
uint varSize;
// The thread that we run console commands in. It's put in the
// background when not in use.
Thread *trd;
// The thread that was running when we started (if any)
Thread *store;
int paren, curl, square;
void delegate(char[] str) output_cb;
bool hasCallback;
char[] norm_prompt = ">>> ";
int tab = 4;
char[] ml_prompt = "... ";
char[] cmt_prompt = "(comment) ";
public:
bool allowVar = true;
this(MonsterObject *ob = null)
{
tn = new Tokenizer();
// Set the context object
obj = ob;
if(obj is null)
obj = Function.getIntMO();
// Next set up the function and the scope
fn.name.str = "__console";
fn.owner = obj.cls;
sc = new FuncScope(obj.cls.sc, &fn);
// Get a new thread
trd = Thread.getPaused();
}
void put(char[] str, bool newLine=false)
{
if(hasCallback)
{
output_cb(str);
if(newLine)
output_cb("\n");
}
else
{
outBuf ~= str;
if(newLine)
outBuf ~= '\n';
}
}
void putln(char[] str) { put(str, true); }
private:
Statement[] parse(TokenArray toks, Scope sc)
{
Statement b;
Statement[] res;
repeat:
b = null;
if(CodeBlock.canParse(toks)) b = new CodeBlock;
else if(IfStatement.canParse(toks)) b = new IfStatement;
else if(DoWhileStatement.canParse(toks)) b = new DoWhileStatement;
else if(WhileStatement.canParse(toks)) b = new WhileStatement;
else if(ForStatement.canParse(toks)) b = new ForStatement;
else if(ForeachStatement.canParse(toks)) b = new ForeachStatement;
else if(ImportStatement.canParse(toks)) b = new ImportStatement(true);
if(b !is null)
{
// Parse and resolve
b.parse(toks);
b.resolve(sc);
}
else
{
// If this is not one of the above, default to a console
// statement.
auto es = new ConsoleStatement;
b = es;
// Parse and resolve in one operation.
es.parseResolve(toks, sc, allowVar);
}
assert(b !is null);
res ~= b;
// Are there more tokens waiting for us?
if(toks.length > 0)
goto repeat;
return res;
}
int sumParen()
{
// Clean up if we had an unmatched end bracket somewhere
if(paren < 0) paren = 0;
if(curl < 0) curl = 0;
if(square < 0) square = 0;
return paren + curl + square;
}
bool isComment()
{
return tn.mode != Tokenizer.Normal;
}
// Resets the console to a usable state. Does not delete variables.
void reset()
{
paren = 0;
curl = 0;
square = 0;
tn.mode = Tokenizer.Normal;
if(cthread is trd)
{
// Reset the function stack.
trd.fstack.killAll();
assert(trd.fstack.isEmpty);
assert(!trd.fstack.hasNatives);
// Our variables should still be on the stack though.
if(stack.getPos > varSize)
stack.popInts(stack.getPos - varSize);
else
assert(stack.getPos == varSize);
// Make sure the thread is still in the 'paused' mode
trd.moveTo(&scheduler.paused);
// Background the thread - this will also capture the stack
trd.background();
}
assert(trd !is cthread);
// Restore the previous thread (if any)
if(store !is null)
store.foreground();
store = null;
}
// Push the input into the compiler and run it
CR runInput(char[] str)
{
// Set up the tokenizer
tn.setLine(str);
// Reset the token buffer, unless we're in a multiline command
if(paren == 0 && curl == 0 && square == 0)
tokArr.length = 0;
// Phase I, tokenize
Token t = tn.getNextFromLine();
// Mark the first token as a newline / separator
t.newline = true;
while(t.type != TT.EMPTY)
{
if(t.type == TT.LeftParen)
paren++;
else if(t.type == TT.LeftCurl)
curl++;
else if(t.type == TT.LeftSquare)
square++;
else if(t.type == TT.RightParen)
paren--;
else if(t.type == TT.RightCurl)
curl--;
else if(t.type == TT.RightSquare)
square--;
tokArr ~= t;
t = tn.getNextFromLine();
}
if(paren < 0 || curl < 0 || square < 0)
fail("Unmatched end bracket(s)");
// Wait for more input inside a bracket
if(sumParen() > 0)
return CR.More;
// Ditto for block comments
if(isComment())
return CR.More;
// Ignore empty token lists
if(tokArr.length == 0)
return CR.Empty;
// Phase II & III, parse and resolve
TokenArray toks = tokArr.arrayCopy();
Statement[] sts = parse(toks, sc);
delete toks;
assert(sts.length >= 1);
// First, background the current thread (if any) and bring up
// our own. This is necessary in order to keep the stack
// variables we make.
store = cthread;
if(store !is null)
store.background();
assert(trd !is null);
trd.foreground();
// We have to push ourselves on the function stack, or
// Function.call() will see that it's empty and kill the thread
// upon exit
trd.fstack.pushExt("Console");
// The rest must be performed separately for each statement on
// the line.
foreach(st; sts)
{
// Phase IV, compile
tasm.newFunc();
// Expression to print, if any
Expression printExp = null;
// Is it a special console statement?
auto cs = cast(ConsoleStatement)st;
if(cs !is null)
{
// Get the client expression, if any.
ExprStatement es = cast(ExprStatement)cs.client;
if(es !is null)
{
// It's a normal expression
if(es.right is null)
printExp = es.left;
}
// Not an expression, maybe a function?
else if(cs.func !is null)
{
// Yup, store it
printExp = cs.func;
}
}
// Ok, we got an expression. But is the type usable?
if(printExp !is null)
{
auto tp = printExp.type;
auto strt = ArrayType.getString();
assert(tp !is null);
assert(strt !is null);
if(tp == strt || tp.canCastTo(strt))
{
// Yup, it is! Cast the expression to string.
strt.typeCast(printExp, "console output");
printExp.eval();
}
else
// Type isn't usable, so set printExp to null to flag
// this.
printExp = null;
}
if(printExp is null)
// No expression is being used, so compile the statement
// normally.
st.compile();
// Gather all the statements into one function and get the
// bytecode.
fn.bcode = tasm.assemble(fn.lines);
fn.bcode ~= cast(ubyte)BC.Exit; // Non-optimal hack
// Phase V, call the function
fn.call(obj);
// Finally, get the expression result, if any, and print it.
if(printExp !is null)
putln(stack.popString8());
// In the case of new a variable declaration, we have to
// make sure they are accessible to any subsequent calls to
// the function. Since the stack frame gets set at each
// call, we have to access the variables outside the
// function frame, ie. the same way we treat function
// parameters. We do this by giving the variables negative
// indices.
if(cs !is null)
{
auto vs = cast(VarDeclStatement)cs.client;
if(vs !is null)
{
// Add the new vars to the list
foreach(v; vs.vars)
{
varList ~= v.var;
// Add the size as well
varSize += v.var.type.getSize;
}
// Recalculate all the indices backwards from zero
int place = 0;
foreach_reverse(v; varList)
{
place -= v.type.getSize;
v.number = place;
}
// Reset the scope stack counters
sc.reset();
}
}
}
trd.fstack.pop();
// Reset the console to a usable state
reset();
return CR.Ok;
}
public:
void prompt()
{
int sum = sumParen();
bool isBracket = (sum != 0);
sum = sum * tab + norm_prompt.length;
if(isComment)
{
sum -= cmt_prompt.length;
while(sum-->0)
put(" ");
put(cmt_prompt);
}
else if(isBracket)
{
sum -= ml_prompt.length;
while(sum-->0)
put(" ");
put(ml_prompt);
}
else
put(norm_prompt);
}
void addImports(char[][] str...)
{
assert(sc !is null);
sc.registerImport(str);
}
// Get the accumulated output since the last call. Includes
// newlines. Will only work if you have not set an output callback
// function.
char[] output()
{
assert(!hasCallback);
char[] res = outBuf.arrayCopy();
outBuf.length = 0;
return res;
}
// Sets the command prompt (default is "> ")
void setPrompt(char[] prmt)
{ norm_prompt = prmt; }
// Sets the multi-line prompt (default is "... ")
void setMLPrompt(char[] prmt)
{ ml_prompt = prmt; }
// Set tab size (default 4)
void setTabSize(int i)
{ tab = i; }
// Get input. Will sometimes expect multi-line input, for example if
// case a line contains an open brace or an unterminated block
// comment. In that case the console will produce another prompt
// (when you call prompt()), and also return true.
CR input(char[] str)
{
str = str.strip();
if(str == "") return CR.Empty;
try return runInput(str);
catch(MonsterException e)
{
putln(e.toString);
reset();
return CR.Error;
}
}
}
// Statement that handles variable declarations, function calls and
// expression statements in consoles. Since these are gramatically
// similar, we need the type to determine which it is.
class ConsoleStatement : Statement
{
// Used for variables and expression statements
Statement client;
// Used for function calls
FunctionCallExpr func;
void parseResolve(ref TokenArray toks, Scope sc, bool allowVar)
{
assert(toks.length != 0);
// Get the first expression
auto first = Expression.identify(toks);
// And the type right away
first.resolve(sc);
auto type = first.type;
assert(type !is null);
// Type? If so, it's a variable declaration
if((type.isMeta || type.isVar) && allowVar)
{
if(type.isMeta) type = type.getBase();
client = new VarDeclStatement(type);
}
// Function?
else if(type.isIntFunc)
func = new FunctionCallExpr(first, toks, true);
// It's an expression statement
else
client = new ExprStatement(first);
if(client !is null)
{
client.parse(toks);
client.resolve(sc);
}
else
{
assert(func !is null);
func.resolve(sc);
}
}
override:
void parse(ref TokenArray) { assert(0); }
void resolve(Scope sc) { assert(0); }
void compile()
{
if(client !is null)
{
client.compile();
return;
}
assert(func !is null);
func.evalPop();
}
}

112
old_d_version/monster/modules/frames.d
Unescape Escape View File

@ -1,112 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (frames.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Provides some simple numbers and functions regarding the rendering
// frames of the application. It's up to the user to some degree to
// provide this information, though. We rely on vm.frame to be called
// each frame.
module monster.modules.frames;
import monster.monster;
import monster.vm.mclass;
import monster.vm.idlefunction;
import monster.vm.thread;
const char[] moduleDef =
"module frames;
float time; // Time since last frame
float totalTime; // Time since rendering started
ulong counter; // Number of frames since program startup
// Sleep a given number of frames
idle fsleep(int frameNum);
"; //"
// Keep local copies of these, since we don't want Monster code to
// overwrite them (we'll be able to explicitly forbid this later.)
ulong frames = 0;
float totTime = 0;
ulong *counter_ptr;
float *time_ptr;
float *totalTime_ptr;
// Add the given time and number of frames to the counters
void updateFrames(float time, int frmCount = 1)
{
// Add up to the totals
frames += frmCount;
totTime += time;
// Set the Monster variables
*counter_ptr = frames;
*time_ptr = time;
*totalTime_ptr = totTime;
// TODO: A similar priority queue like we're planning for timer
// would also be applicable here. However I'm guessing frameSleep()
// will be used a lot less than sleep() though, so this is really
// not high up on the priority list.
}
// Idle function that sleeps a given number of frames before
// returning.
class IdleFrameSleep : IdleFunction
{
override:
IS initiate(Thread* cn)
{
// Calculate the return frame
cn.idleData.l = frames + stack.popInt;
// Schedule us
return IS.Poll;
}
bool hasFinished(Thread* cn)
{
// Are we at (or past) the correct frame?
return frames >= cn.idleData.l;
}
}
void initFramesModule()
{
static MonsterClass mc;
if(mc !is null) return;
mc = vm.loadString(moduleDef, "frames");
// Bind the idle
mc.bind("fsleep", new IdleFrameSleep);
// Get pointers to the variables so we can write to them easily.
auto mo = mc.getSing();
counter_ptr = mo.getUlongPtr("counter");
time_ptr = mo.getFloatPtr("time");
totalTime_ptr = mo.getFloatPtr("totalTime");
}

9
old_d_version/monster/modules/frames.mn
Unescape Escape View File

@ -1,9 +0,0 @@
module frames;
float time; // Time since last frame
float totalTime; // Time since rendering started
ulong counter; // Number of frames since program startup
// Sleep a given number of frames
idle fsleep(int frameNum);

92
old_d_version/monster/modules/io.d
Unescape Escape View File

@ -1,92 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (io.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// This module provides simple output functions for Monster. The 'i'
// (input) part of 'io' isn't really there yet.
module monster.modules.io;
import monster.monster;
const char[] moduleDef =
"module io;
native write(char[][] args...);
native writeln(char[][] args...);
native writes(char[][] args...);
native writelns(char[][] args...);
native print(char[][] args...);
"; //"
// Use tango library functions directly, since flushing the
// minibos-versions will give weird effects when mixing with other
// tango output.
version(Tango)
{
import tango.io.Stdout;
void doWrite(bool space)
{
AIndex[] args = stack.popAArray();
char[] form = "{}";
if(space) form = "{} ";
foreach(AIndex ind; args)
Stdout.format(form, arrays.getRef(ind).carr);
Stdout.flush();
}
void writefln() { Stdout.newline; }
}
else
{ // Phobos
import std.stdio;
void doWrite(bool space)
{
AIndex[] args = stack.popAArray();
char[] form = "%s";
if(space) form = "%s ";
foreach(AIndex ind; args)
writef(form, arrays.getRef(ind).carr);
fflush(stdout);
}
}
void initIOModule()
{
static MonsterClass mc;
if(mc !is null) return;
mc = vm.loadString(moduleDef, "io");
mc.bind("write", { doWrite(false); });
mc.bind("writeln", { doWrite(false); writefln(); });
mc.bind("writes", { doWrite(true); });
mc.bind("writelns", { doWrite(true); writefln(); });
// Print is just another name for writelns
mc.bind("print", { doWrite(true); writefln(); });
}

17
old_d_version/monster/modules/io.mn
Unescape Escape View File

@ -1,17 +0,0 @@
/*
NOTE: This file is not used - it is here just for reference. The
real module is defined internally in io.d.
*/
module io;
// Write to console, with or without a newline
native write(char[][] args...);
native writeln(char[][] args...);
// Automatically inserts spaces between arguments
native writes(char[][] args...);
native writelns(char[][] args...);
// Identical to writelns
native print(char[][] args...);

166
old_d_version/monster/modules/math.d
Unescape Escape View File

@ -1,166 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (math.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Simple math functions
module monster.modules.math;
import monster.monster;
import std.math;
import monster.vm.mclass;
const char[] moduleDef =
"module math;
double E = 2.7182818284590452354;
double PI = 3.141592653589793238;
double DEGTORAD = 3.141592653590/180;
double RADTODEG = 180/3.141592653590;
native double sin(double x);
native double cos(double x);
native double tan(double x);
native double asin(double x);
native double acos(double x);
native double atan(double x);
native double atan2(double y, double x); // = atan(y/x)
native double sinh(double x);
native double cosh(double x);
native double tanh(double x);
native double asinh(double x);
native double acosh(double x);
native double atanh(double x);
native double sqrt(double x);
native double exp(double x); // e^x
native double exp2(double x); // 2^x
native double log(double x); // base e
native double log10(double x);// base 10
native double log2(double x); // base 2
native double pow(double x, double y); // x^y
native double ipow(double x, int n); // x^n (faster than pow)
native int abs(int x);
native double fabs(double x);
native double ceil(double x);
native double floor(double x);
native double round(double x); // rounds to nearest integer
native double trunc(double x);
native double hypot(double x, double y); // = sqrt(x*x+y*y)
native double cbrt(double x); // cube root
// Calculates polynomial a0 + x*a1 + x^2*a2 + x^3*a3 + ...
native double poly(double x, float[] A);
"; //"
version(Tango)
{
double fabs(double x) { return abs(x); }
}
void initMathModule()
{
static MonsterClass mc;
if(mc !is null) return;
mc = vm.loadString(moduleDef, "math");
mc.bind("sin", { stack.pushDouble(sin(stack.popDouble)); });
mc.bind("cos", { stack.pushDouble(cos(stack.popDouble)); });
mc.bind("tan", { stack.pushDouble(tan(stack.popDouble)); });
mc.bind("asin", { stack.pushDouble(asin(stack.popDouble)); });
mc.bind("acos", { stack.pushDouble(acos(stack.popDouble)); });
mc.bind("atan", { stack.pushDouble(atan(stack.popDouble)); });
mc.bind("sinh", { stack.pushDouble(sinh(stack.popDouble)); });
mc.bind("cosh", { stack.pushDouble(cosh(stack.popDouble)); });
mc.bind("tanh", { stack.pushDouble(tanh(stack.popDouble)); });
mc.bind("asinh", { stack.pushDouble(asinh(stack.popDouble)); });
mc.bind("acosh", { stack.pushDouble(acosh(stack.popDouble)); });
mc.bind("atanh", { stack.pushDouble(atanh(stack.popDouble)); });
mc.bind("atan2",
{
// Remember to pop the variables in the reverse order
auto x = stack.popDouble;
stack.pushDouble(atan2(stack.popDouble, x));
});
mc.bind("sqrt", { stack.pushDouble(sqrt(stack.popDouble)); });
mc.bind("exp", { stack.pushDouble(exp(stack.popDouble)); });
mc.bind("exp2", { stack.pushDouble(exp2(stack.popDouble)); });
mc.bind("log", { stack.pushDouble(log(stack.popDouble)); });
mc.bind("log2", { stack.pushDouble(log2(stack.popDouble)); });
mc.bind("log10", { stack.pushDouble(log10(stack.popDouble)); });
mc.bind("pow",
{
auto x = stack.popDouble;
stack.pushDouble(pow(stack.popDouble, x));
});
mc.bind("ipow",
{
auto x = stack.popInt;
stack.pushDouble(pow(cast(real)stack.popDouble, x));
});
mc.bind("abs", { stack.pushDouble(abs(stack.popDouble)); });
mc.bind("fabs", { stack.pushDouble(fabs(stack.popDouble)); });
mc.bind("ceil", { stack.pushDouble(ceil(stack.popDouble)); });
mc.bind("floor", { stack.pushDouble(floor(stack.popDouble)); });
mc.bind("round", { stack.pushDouble(round(stack.popDouble)); });
mc.bind("trunc", { stack.pushDouble(trunc(stack.popDouble)); });
// Order doesn't matter here
mc.bind("hypot", { stack.pushDouble(hypot(stack.popDouble,
stack.popDouble)); });
mc.bind("cbrt", { stack.pushDouble(cbrt(stack.popDouble)); });
mc.bind("poly", &npoly);
}
// Implement this ourselves, since phobos doesn't use the types we
// want
double poly(double x, float A[])
{
// Use 'real' internally for higher precision
real r = A[$-1];
foreach_reverse(c; A[0..$-1])
{
r *= x;
r += c;
}
return r;
}
// double poly(double x, float[] A);
void npoly()
{
auto arf = stack.popArray();
assert(arf.elemSize == 1);
stack.pushDouble(poly(stack.popDouble, arf.farr));
}

43
old_d_version/monster/modules/math.mn
Unescape Escape View File

@ -1,43 +0,0 @@
module math;
double E = 2.7182818284590452354;
double PI = 3.141592653589793238;
double DEGTORAD = 3.141592653590/180;
double RADTODEG = 180/3.141592653590;
native double sin(double x);
native double cos(double x);
native double tan(double x);
native double asin(double x);
native double acos(double x);
native double atan(double x);
native double atan2(double y, double x); // = atan(y/x)
native double sinh(double x);
native double cosh(double x);
native double tanh(double x);
native double asinh(double x);
native double acosh(double x);
native double atanh(double x);
native double sqrt(double x);
native double exp(double x); // e^x
native double exp2(double x); // 2^x
native double log(double x); // base e
native double log10(double x);// base 10
native double log2(double x); // base 2
native double pow(double x, double y); // x^y
native double ipow(double x, int n); // x^n (faster than pow)
native int abs(int x);
native double fabs(double x);
native double ceil(double x);
native double floor(double x);
native double round(double x); // rounds to nearest integer
native double trunc(double x);
native double hypot(double x, double y); // = sqrt(x*x+y*y)
native double cbrt(double x); // cube root
// Calculates polynomial a0 + x*a1 + x^2*a2 + x^3*a3 + ...
native double poly(double x, float[] A);

71
old_d_version/monster/modules/random.d
Unescape Escape View File

@ -1,71 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (random.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// This module provides simple random number generation. Since this is
// intended for game development, speed and simplicity is favored over
// flexibility and random number quality.
module monster.modules.random;
import monster.monster;
import std.random;
const char[] moduleDef =
"module random;
native uint rand(); // Return a number between 0 and uint.max, inclusive
native float frand(); // Return a number between 0 and 1, inclusive
// Return a random number between a and b, inclusive. Allows negative
// numbers, and works with a>b, a<b and a==b
native int randInt(int a, int b);
"; //"
const float _frandFactor = 1.0/uint.max;
// Return a random integer between a and b, inclusive.
int randInt(int a, int b)
out(result)
{
// Result must be in range m <= result <= M, where m=min(a,b) and M=max(a,b)
if(b >= a) assert( (a <= result) && (result <= b) );
else if(a > b) assert( (b <= result) && (result <= a) );
}
body
{
if(a>b) return cast(int)(rand() % (a-b+1)) + b;
else if(b>a) return cast(int)(rand() % (b-a+1)) + a;
else return a;
}
void initRandomModule()
{
static MonsterClass mc;
if(mc !is null) return;
mc = vm.loadString(moduleDef, "random");
mc.bind("rand", { stack.pushInt(rand()); });
mc.bind("frand", { stack.pushFloat(rand()*_frandFactor); });
mc.bind("randInt", { stack.pushInt(randInt(stack.popInt,
stack.popInt)); });
}

8
old_d_version/monster/modules/random.mn
Unescape Escape View File

@ -1,8 +0,0 @@
module random;
native uint rand(); // Return a number between 0 and uint.max, inclusive
native float frand(); // Return a number between 0 and 1, inclusive
// Return a random number between a and b, inclusive. Allows negative
// numbers, and works with a>b, a<b and a==b
native int randInt(int a, int b);

39
old_d_version/monster/modules/thread.mn
Unescape Escape View File

@ -1,39 +0,0 @@
/*
NOTE: This file is not used - it is here just for reference. The
real module is defined internally in io.d.
*/
singleton thread;
// Used to kill or pause our own or other threads.
idle kill();
idle pause();
// Get status information about a thread
native bool isScheduled();
native bool isPaused();
native bool isIdle();
native bool isDead();
bool isAlive() { return !isDead(); }
// Create a new (paused) thread for a given function
native thread create(function() f);
// Schedule a (paused) thread to run the next frame
native restart();
// Call a (paused) thread directly - returns when the thread exits or
// calls an idle function.
idle call();
// Wait for a thread to finish. Will not return until the thread is
// dead.
idle wait();
// Start a function as a thread in the background
thread start(function() f)
{
var t = create(f);
t.restart();
return t;
}

279
old_d_version/monster/modules/threads.d
Unescape Escape View File

@ -1,279 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (threads.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// This module provides an interface to the virtual threading API in
// Monster.
module monster.modules.threads;
import monster.monster;
import monster.vm.mobject;
import monster.vm.idlefunction;
import monster.vm.thread;
import monster.vm.mclass;
import monster.compiler.functions;
import std.stdio;
const char[] moduleDef =
"singleton thread;
// Used to kill or pause our own or other threads.
idle kill();
idle pause();
// Get status information about a thread
native bool isScheduled();
native bool isPaused();
native bool isIdle();
native bool isDead();
bool isAlive() { return !isDead(); }
// Create a new (paused) thread for a given function
native thread create(function() f);
// Schedule a (paused) thread to run the next frame
native restart();
// Call a (paused) thread directly - returns when the thread exits or
// calls an idle function.
idle call();
// Wait for a thread to finish. Will not return until the thread is
// dead.
idle wait();
// Start a function as a thread in the background
thread start(function() f)
{
var t = create(f);
t.restart();
return t;
}"; //"
/*
The char[] name stuff above will of course be replaced with real
function pointers once those are done. When closures are done we
will also add:
function() wrap(function() f)
{
var t = create(f);
return { t.call(); }
}
*/
MonsterObject *trdSing;
class Kill : IdleFunction
{
IS initiate(Thread *t)
{
auto mo = params.obj;
if(mo !is trdSing)
{
// Check if this is another thread
auto trd = getOwner(mo);
if(trd !is t)
{
// It is. Kill it explicitly and return.
trd.kill();
return IS.Return;
}
}
// If it's our own thread, tell the scheduler to kill it from
// the inside.
return IS.Kill;
}
}
class Pause : IdleFunction
{
IS initiate(Thread *t)
{
auto mo = params.obj;
// Can only run on the singleton object
if(mo !is trdSing)
fail("Can only pause our own thread");
// Move the thread to the 'paused' list
t.moveTo(&scheduler.paused);
return IS.Manual;
}
}
Thread *getOwner() { return getOwner(params.obj); }
Thread *getOwner(MonsterObject *mo)
{
assert(mo !is null);
if(mo is trdSing)
fail("Cannot run this function on the global singleton thread.");
auto trd = cast(Thread*) mo.getExtra(_threadClass).vptr;
assert(trd !is null);
assert(!trd.isRunning || !trd.isPaused,
"thread cannot be running and paused at the same time");
return trd;
}
MonsterObject *createObj(Thread *trd)
{
assert(trd !is null);
auto mo = _threadClass.createObject();
mo.getExtra(_threadClass).vptr = trd;
return mo;
}
void create()
{
// Can only run on the singleton object
if(params.obj !is trdSing)
fail("Can only use create() on the global thread object.");
auto fn = stack.popFuncRef();
auto trd = fn.getObject().thread(fn.getFunction());
stack.pushObject(createObj(trd));
}
// Call is used to restore a thread that was previously paused. It
// will enter the thread immediately, like a normal function call, but
// it will still run in its own thread. If you only wish to schedule
// it for later, use restart instead.
class Call : IdleFunction
{
override:
IS initiate(Thread *t)
{
if(params.obj is trdSing)
fail("Cannot use call() on our own thread.");
// Get the thread we're resuming
auto trd = getOwner();
if(trd is t)
fail("Cannot use call() on our own thread.");
if(trd.isDead)
fail("Cannot call a dead thread.");
if(!trd.isPaused)
fail("Can only use call() on paused threads");
// Background the current thread. Move it to the pause list
// first, so background doesn't inadvertently delete it.
t.moveTo(&scheduler.paused);
t.background();
assert(!t.isDead);
// Reenter the thread
trd.reenter();
assert(cthread is null);
// Put the old thread in the forground again
t.foreground();
// Make the thread transient again
t.moveTo(&scheduler.transient);
// Return to sender
return IS.Return;
}
void abort(Thread *t)
{
fail("Cannot abort thread while it is calling another thread");
}
}
class Wait : IdleFunction
{
override:
IS initiate(Thread *t)
{
if(params.obj is trdSing)
fail("Cannot use wait on our own thread.");
// Get the thread we're resuming
auto trd = getOwner();
if(trd is t)
fail("Cannot use wait on our own thread.");
// Return immediately if the thread is dead
if(trd.isDead)
return IS.Return;
t.idleData.vptr = trd;
return IS.Poll;
}
bool hasFinished(Thread *t)
{
return (cast(Thread*)t.idleData.vptr).isDead;
}
}
void restart()
{ getOwner().restart(); }
void isDead()
{ stack.pushBool(getOwner().isDead); }
void isIdle()
{ stack.pushBool(getOwner().fstack.isIdle); }
void isPaused()
{ stack.pushBool(getOwner().isPaused); }
void isScheduled()
{ stack.pushBool(getOwner().isScheduled); }
MonsterClass _threadClass;
void initThreadModule()
{
if(_threadClass !is null)
return;
_threadClass = vm.loadString(moduleDef, "thread");
trdSing = _threadClass.getSing();
_threadClass.bind("kill", new Kill);
_threadClass.bind("call", new Call);
_threadClass.bind("pause", new Pause);
_threadClass.bind("wait", new Wait);
_threadClass.bind("create", &create);
_threadClass.bind("restart", &restart);
_threadClass.bind("isDead", &isDead);
_threadClass.bind("isIdle", &isIdle);
_threadClass.bind("isPaused", &isPaused);
_threadClass.bind("isScheduled", &isScheduled);
}

190
old_d_version/monster/modules/timer.d
Unescape Escape View File

@ -1,190 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (timer.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// This module contains (or will contain) various routines for
// timing. It is also home of the ubiquitous "sleep" idle function.
module monster.modules.timer;
import std.stdio;
// For some utterly idiotic reason, DMD's public imports will suddenly
// stop working from time to time.
import monster.vm.mclass;
import monster.vm.mobject;
import monster.vm.stack;
import monster.vm.thread;
import monster.vm.idlefunction;
import monster.monster;
import monster.options;
const char[] moduleDef =
"singleton timer;
idle sleep(float secs);
"; //"
static if(timer_useClock)
{
// Sleep a given amount of time. This implementation uses the system
// clock.
import std.date;
class IdleSleep_SystemClock : IdleFunction
{
override:
IS initiate(Thread* cn)
{
// Get the parameter
float secs = stack.popFloat;
// Get current time
cn.idleData.l = getUTCtime();
// Calculate when we should return
cn.idleData.l += secs*TicksPerSecond;
// Schedule us
return IS.Poll;
}
bool hasFinished(Thread* cn)
{
// Is it time?
return getUTCtime() >= cn.idleData.l;
}
}
} else { // If timer_useClock is NOT set:
// This implementation uses a user-driven timer instead of the system
// clock. It's more efficient, but requires the user to update the
// given timer manually each frame. The default sleep (timer.sleep) is
// bound to the default timer, but it's possible to create multiple
// independent timers.
class IdleSleep_Timer : IdleFunction
{
override:
IS initiate(Thread* cn)
{
// The timer is stored in the object's 'extra' pointer
auto t = cast(SleepManager)cn.extraData.obj;
assert(t !is null);
// Calculate the return time
cn.idleData.l = t.current + cast(long)(t.tickSize*stack.popFloat);
// Schedule us
return IS.Poll;
}
bool hasFinished(Thread* cn)
{
// Get the timer
auto t = cast(SleepManager)cn.extraData.obj;
assert(t !is null);
// Is it time?
return t.current >= cn.idleData.l;
}
}
// A manually updated timer. This can be improved quite a lot: Most
// sleep operations (depending on application of course) will skip
// many frames before they return. For example, for sleep(0.5) at 100
// fps, hasFinished will return false approximately 50 times before
// returning true. For bigger sleep values and a large number of
// objects, the impact of this is significant. A good solution would
// be to pool scheduled objects together and only perform one check on
// the entire pool. If the pool is due, all the nodes within it are
// inserted into the scheduler for detailed checking. We could have a
// series of such pools, ordered by expiration time, so that we only
// ever need to check the first pool in the list. The optimal pool
// interval, number of pools etc depends on the application and the
// fps - but it should be possible to find some reasonable defaults. A
// more generalized priority queue implementation is also possible.
class SleepManager
{
private:
// Instance of the timer class that is associated with this timer
MonsterObject *tobj;
// Current tick count
long current;
public:
// Specify a Monster object to associate with this timer. Use 'null'
// if you don't need an object.
this(MonsterObject *obj)
{
if(obj is null) return;
tobj = obj;
tobj.getExtra(_timerClass).obj = this;
}
// By default, create a new object
this()
{ this(_timerClass.createObject); }
// Number of 'ticks' per second
static const long tickSize = 1000;
// Reset the timer to zero
void reset() { current = 0; }
// Return the total number of elapsed seconds since start (or last
// reset)
double read() { return current/cast(double)tickSize; }
// Add time to the timer.
void add(double d) { current += cast(long)(tickSize*d); }
void addl(long l) { current += l; }
MonsterObject *getObj() { return tobj; }
}
SleepManager idleTime;
}
MonsterClass _timerClass;
void initTimerModule()
{
if(_timerClass !is null)
return;
_timerClass = vm.loadString(moduleDef, "timer");
static if(timer_useClock)
{
_timerClass.bind("sleep", new IdleSleep_SystemClock);
}
else
{
assert(idleTime is null);
idleTime = new SleepManager(_timerClass.getSing());
_timerClass.bind("sleep", new IdleSleep_Timer);
}
}

9
old_d_version/monster/modules/timer.mn
Unescape Escape View File

@ -1,9 +0,0 @@
/*
NOTE: This file is not used - it is here just for reference. The
real module is defined internally in timer.d.
*/
singleton timer;
// Sleep the given number of seconds
idle sleep(float secs);

183
old_d_version/monster/modules/vfs.d
Unescape Escape View File

@ -1,183 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (vfs.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.modules.vfs;
import std.file;
import std.stream;
import std.string;
import monster.util.string;
import monster.vm.error;
abstract class VFS
{
// Abstract functions. These must be implemented in child classes.
// Return true if a file exists. Should not return true for
// directories.
abstract bool has(char[] file);
abstract bool hasDir(char[] dir);
// Open the given file and return it as a stream.
abstract Stream open(char[] file);
// Check for invalid file names. This makes sure the caller cannot
// read files outside the designated subdirectory.
final static void checkForEscape(char[] file)
{
if(file.begins("/") || file.begins("\\"))
fail("Filename " ~ file ~ " cannot begin with a path separator");
if(file.find(":") != -1)
fail("Filename " ~ file ~ " cannot contain colons");
if(file.find("..") != -1)
fail("Filename " ~ file ~ " cannot contain '..'");
}
}
// A VFS that contains a list of other VFS objects
class ListVFS : VFS
{
private:
VFS[] list;
public:
this(VFS v[] ...)
{ list = v; }
void add(VFS v[] ...)
{ list ~= v; }
void addFirst(VFS v[] ...)
{ list = v ~ list; }
bool has(char[] file)
{
foreach(l; list)
if(l.has(file)) return true;
return false;
}
bool hasDir(char[] file)
{
foreach(l; list)
if(l.hasDir(file)) return true;
return false;
}
Stream open(char[] file)
{
foreach(l; list)
if(l.has(file)) return l.open(file);
fail("No member VFS contains file " ~ file);
}
}
// A VFS that reads files from a given path in the OS file
// system. Disallows filenames that escape the given path,
// ie. filenames such as:
//
// /etc/passwd
// dir/../../file
// c:\somefile
class FileVFS : VFS
{
private:
char[] sysPath;
char[] buffer;
char[] getPath(char[] file)
{
// Make sure the buffer is large enough
if(buffer.length < file.length+sysPath.length)
buffer.length = file.length + sysPath.length + 50;
checkForEscape(file);
// Copy the file name over
buffer[sysPath.length .. sysPath.length+file.length]
= file[];
// Convert the path characters
convPath();
// Return the result
return buffer[0..sysPath.length+file.length];
}
// Convert path separators
void convPath()
{
foreach(ref c; buffer)
if(c == from)
c = to;
}
version(Windows)
{
const char from = '/';
const char to = '\\';
}
else
{
const char from = '\\';
const char to = '/';
}
public:
this(char[] path = "")
{
// Set up the initial buffer
buffer.length = path.length + 50;
if(path.length)
{
// Slice the beginning of it and copy the path over
sysPath = buffer[0..path.length];
sysPath[] = path[];
}
convPath();
// Make sure the last char in the path is a path separator
if(!path.ends([to]))
{
sysPath = buffer[0..path.length+1];
sysPath[$-1] = to;
}
}
bool has(char[] file)
{
char[] pt = getPath(file);
return exists(pt) && isfile(pt);
}
bool hasDir(char[] file)
{
char[] pt = getPath(file);
return exists(pt) && isdir(pt);
}
Stream open(char[] file)
{ return new BufferedFile(getPath(file)); }
}

42
old_d_version/monster/monster.d
Unescape Escape View File

@ -1,42 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (monster.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.monster;
public
{
// These should contain all you need for normal usage.
import monster.vm.mobject;
import monster.vm.mclass;
import monster.vm.stack;
import monster.vm.vm;
import monster.vm.thread;
import monster.vm.idlefunction;
import monster.vm.arrays;
import monster.vm.params;
import monster.vm.error;
}
version(LittleEndian) {}
else static assert(0, "This library does not yet support big endian systems.");

192
old_d_version/monster/options.d
Unescape Escape View File

@ -1,192 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (options.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.options;
/*
The purpose of this file is to set compile time options for the
Monster library - including compiler, VM and modules. This allows
the user to customize the language in various ways to fit each
project individually.
For changes to take effect, you must recompile and reinstall the
library.
If you have suggestions for additional options and ways to customize
the language, let us know!
*/
static:
const:
/*********************************************************
Language options
*********************************************************/
// Set to false to make the entire language case insensitive. Affects
// all identifier and keyword matching. (Not implemented yet!)
bool caseSensitive = true;
// Include the case-insensitive string (and character) operators =i=,
// =I=, !=i= and !=I=.
bool ciStringOps = true;
// Skip lines beginning with a hash character '#'
bool skipHashes = true;
// Do we allow implicit downcasting of classes? Downcasting means
// casting from a parent class to a child class. The actual object
// type is checked at runtime. In any case you can always downcast
// explicitly, using ClassName(obj).
bool implicitDowncast = true;
// Allow implicit conversion from float to int (and similar
// conversions). If false, you must use explicit casting,
// ie. int(value)
bool implicitTruncate = false;
/*********************************************************
VM options
*********************************************************/
// Whether to add the current working directory to the VFS at
// startup. If false, you must add your own directories (using
// vm.addPath) or your own VFS implementations, otherwise the library
// will not be able to find any script files.
bool vmAddCWD = false;
// Maximum stack size. Prevents stack overflow through infinite
// recursion and other bugs.
int maxStack = 100;
// Maximum function stack size
int maxFStack = 100;
// Whether we should limit the number of instructions that execute()
// can run at once. Enabling this will prevent infinite loops.
bool enableExecLimit = true;
// Maximum number of instructions to allow in each call to execute()
// (if enableExecLimit is true)
long execLimit = 10000000;
/*********************************************************
Debugging options
*********************************************************/
// If true, set the log output to standard out. If false, logging is
// disabled by default and must be activated (through monster.vm.dbg)
// at runtime.
bool defaultLogToStdout = false;
// If true, all function stack operations (pushes and pops) are logged
// with dbg.log(), and all logged messages are indented according to
// the current fstack level.
bool logFStack = true;
// If true, log when threads are put into the background/forground.
bool logThreads = true;
// The following options control more low-level debugging. Most of
// these will enable tracing of various internal function calls and
// parameters directly to stdout.
// Trace the thread system
bool traceThreads = false;
// Trace scope lookups
bool traceLookups = false;
// Trace resolve() calls
bool traceResolve = false;
// Print completed output from the assembler
bool printAsmOutput = false;
// Trace VM opcode execution
bool traceVMOps = false;
/*********************************************************
Optimization options
*********************************************************/
// Enable assembler optimizations
bool optimizeAsm = true;
/*********************************************************
Modules
*********************************************************/
// Load modules at startup? If false, you can still load modules
// manually using monster.modules.all.initAllModules().
bool loadModules = true;
// List of modules to load when initAllModules is called (and at
// startup if loadModules is true.)
char[] moduleList = "io math timer frames random thread";
/*********************************************************
Timer module
*********************************************************/
// When true, idle function sleep() uses the system clock. When false,
// the time is only updated manually when the user calls vm.frame().
// The system clock is fine for small applications, but the manual
// method is much more optimized. It is highly recommended to use
// vm.frame() manually for games and other projects that use a
// rendering loop.
bool timer_useClock = false;

192
old_d_version/monster/options.openmw
Unescape Escape View File

@ -1,192 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (options.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.options;
/*
The purpose of this file is to set compile time options for the
Monster library - including compiler, VM and modules. This allows
the user to customize the language in various ways to fit each
project individually.
For changes to take effect, you must recompile and reinstall the
library.
If you have suggestions for additional options and ways to customize
the language, let us know!
*/
static:
const:
/*********************************************************
Language options
*********************************************************/
// Set to false to make the entire language case insensitive. Affects
// all identifier and keyword matching. (Not implemented yet!)
bool caseSensitive = true;
// Include the case-insensitive string (and character) operators =i=,
// =I=, !=i= and !=I=.
bool ciStringOps = true;
// Skip lines beginning with a hash character '#'
bool skipHashes = true;
// Do we allow implicit downcasting of classes? Downcasting means
// casting from a parent class to a child class. The actual object
// type is checked at runtime. In any case you can always downcast
// explicitly, using ClassName(obj).
bool implicitDowncast = true;
// Allow implicit conversion from float to int (and similar
// conversions). If false, you must use explicit casting,
// ie. int(value)
bool implicitTruncate = false;
/*********************************************************
VM options
*********************************************************/
// Whether to add the current working directory to the VFS at
// startup. If false, you must add your own directories (using
// vm.addPath) or your own VFS implementations, otherwise the library
// will not be able to find any script files.
bool vmAddCWD = false;
// Maximum stack size. Prevents stack overflow through infinite
// recursion and other bugs.
int maxStack = 100;
// Maximum function stack size
int maxFStack = 100;
// Whether we should limit the number of instructions that execute()
// can run at once. Enabling this will prevent infinite loops.
bool enableExecLimit = true;
// Maximum number of instructions to allow in each call to execute()
// (if enableExecLimit is true)
long execLimit = 10000000;
/*********************************************************
Debugging options
*********************************************************/
// If true, set the log output to standard out. If false, logging is
// disabled by default and must be activated (through monster.vm.dbg)
// at runtime.
bool defaultLogToStdout = false;
// If true, all function stack operations (pushes and pops) are logged
// with dbg.log(), and all logged messages are indented according to
// the current fstack level.
bool logFStack = true;
// If true, log when threads are put into the background/forground.
bool logThreads = true;
// The following options control more low-level debugging. Most of
// these will enable tracing of various internal function calls and
// parameters directly to stdout.
// Trace the thread system
bool traceThreads = false;
// Trace scope lookups
bool traceLookups = false;
// Trace resolve() calls
bool traceResolve = false;
// Print completed output from the assembler
bool printAsmOutput = false;
// Trace VM opcode execution
bool traceVMOps = false;
/*********************************************************
Optimization options
*********************************************************/
// Enable assembler optimizations
bool optimizeAsm = true;
/*********************************************************
Modules
*********************************************************/
// Load modules at startup? If false, you can still load modules
// manually using monster.modules.all.initAllModules().
bool loadModules = true;
// List of modules to load when initAllModules is called (and at
// startup if loadModules is true.)
char[] moduleList = "io math timer frames random thread";
/*********************************************************
Timer module
*********************************************************/
// When true, idle function sleep() uses the system clock. When false,
// the time is only updated manually when the user calls vm.frame().
// The system clock is fine for small applications, but the manual
// method is much more optimized. It is highly recommended to use
// vm.frame() manually for games and other projects that use a
// rendering loop.
bool timer_useClock = false;

16
old_d_version/monster/update.sh
Unescape Escape View File

@ -1,16 +0,0 @@
#!/bin/bash
svn export https://monster-script.svn.sourceforge.net/svnroot/monster-script/trunk/monster/ . --force
rm -r minibos vm/c_api.d
for a in $(find -iname \*.d); do
cat "$a" | sed s/monster.minibos./std./g > "$a"_new
mv "$a"_new "$a"
done
svn st
diff options.openmw options.d || $EDITOR options.d
mv options.openmw options.openmw_last
cp options.d options.openmw

1033
old_d_version/monster/util/aa.d
View File

File diff suppressed because it is too large Load Diff

147
old_d_version/monster/util/flags.d
Unescape Escape View File

@ -1,147 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (flags.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.util.flags;
// A generic bitwise flag manager.
struct Flags(T)
{
T flags;
void set(T t)
{ flags |= t; }
void unset(T t)
{ flags ^= flags & t; }
void set(T t, bool value)
{
if(value) set(t);
else unset(t);
assert(has(t) == value);
}
// Does it have all of the bits in the parameter set?
bool has(T t)
{ return (flags & t) == t; }
// Does it have any of the bits in the parameter set?
bool hasAny(T t)
{ return (flags & t) != 0; }
// For single-bit parameters, has() and hasAny() are identical.
}
unittest
{
Flags!(int) fl;
assert(fl.flags == 0);
// Try setting some flags
assert(!fl.has(2));
fl.set(2);
assert(fl.has(2));
assert(!fl.has(4));
fl.set(4, true);
assert(fl.has(4));
assert(fl.flags == 6);
// Make sure setting them again won't change anything
fl.set(2);
assert(fl.flags == 6);
fl.set(4);
assert(fl.flags == 6);
fl.set(2, true);
assert(fl.flags == 6);
fl.set(4, true);
assert(fl.flags == 6);
// Test the has() and hasAny() functions
with(fl)
{
assert( !has(1) ); // 1 is not set
assert( has(2) ); // 2 is set
assert( !has(3) ); // 2+1 is NOT set, because 1 is missing
assert( has(4) ); // 4 is set
assert( !has(5) ); // 4+1 is NOT set, 1 is missing
assert( has(6) ); // 2+4 is set because both are present
assert( !has(7) ); // 1+2+4 not set, 1 missing
assert( !hasAny(1) );// 1 is not set
assert( hasAny(2) ); // 2 is set
assert( hasAny(3) ); // 2 is set and part of 3=1+2
assert( hasAny(4) ); // 4 is set
assert( hasAny(5) ); // 4 is and is part of 5=1+4
assert( hasAny(6) ); // 2+4 is set
assert( hasAny(7) ); // 2+4 are part of 7
assert( !hasAny(8) );
assert( !hasAny(9) );
}
// Set a mixed flag
fl.set(3);
assert(fl.has(3));
assert(fl.has(7));
assert(fl.flags == 7);
// Unset a flag
fl.unset(2);
assert(fl.flags == 5);
// And again
fl.unset(2);
assert(fl.flags == 5);
// Set and unset it with set()
fl.set(2,true);
assert(fl.flags == 7);
fl.set(2,false);
assert(fl.flags == 5);
// Now try an enum
enum MF
{
A = 1,
B = 2,
AB = 3,
C = 4
}
Flags!(MF) mf;
mf.set(MF.A);
assert(mf.has(MF.A));
assert(!mf.has(MF.AB));
mf.set(MF.B, true);
assert(mf.has(MF.B));
assert(mf.has(MF.AB));
mf.unset(MF.B);
assert(mf.has(MF.A));
assert(!mf.has(MF.B));
assert(!mf.has(MF.AB));
}

401
old_d_version/monster/util/freelist.d
Unescape Escape View File

@ -1,401 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (freelist.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.util.freelist;
import monster.util.list;
import monster.util.growarray;
import std.c.stdlib : malloc, free;
// A freelist for buffers of a given size. The 'size' template
// parameter gives the total requested size of the entire struct,
// including overhead.
struct BufferList(int size)
{
// Calculate the 'overhead' size of the structs
alias void* vp;
static const junk = 2*vp.sizeof + int.sizeof;
static union BuffData(int size)
{
static assert(size >= 2, "size must be at least 2");
int[size/int.sizeof] ints;
ubyte[size] bytes;
}
// Get the data sizes
static const bytes = size - junk;
static const ints = bytes / int.sizeof;
static assert(bytes > 0, "size is too small");
alias BuffData!(bytes) Value;
alias Value* ValuePtr;
static assert(Value.sizeof == bytes);
alias LinkedList!(Value, NoAlloc) List;
alias List.Node LNode;
static struct BufferNode(int size)
{
LNode data;
int index;
}
alias BufferNode!(bytes) Node;
alias Node* NodePtr;
static assert(Node.sizeof == size);
private:
// This is the array that does all the actual allocations. It is
// used for quickly looking up indices. GrowArrays are designed to
// grow dynamically without reallocation, while still being easily
// indexed like a normal array.
static GrowArray!(Node) array;
// The freelist. This is shared between all template instances of
// the same size.
static List freeList;
// The nodes belonging to THIS list instance
List nodes;
// Get a new node (move from freelist to node list)
ValuePtr getNew()
{
// Is the freelist empty?
if(freeList.length == 0)
{
// Create a bunch of nodes and shove them into the freelist.
const makeSize = 50;
// Grow the growarray
uint len = array.length;
array.length = len + makeSize;
// Loop through the new nodes, number them, and insert them
// into freeList
for(int i=0; i < makeSize; i++)
{
NodePtr fn = array.getPtr(i+len);
fn.index = i + len;
freeList.insertNode(&fn.data);
}
}
// Move the first element from the freelist into the node list.
auto node = freeList.getHead;
freeList.removeNode(node);
nodes.insertNodeFirst(node);
// Return the value pointer. Since the value is always at the
// begining of the Node struct, this is the same
// pointer.
return &node.value;
}
// Move a node back to the freelist ("delete" it)
void remove(ValuePtr node)
{
nodes.removeNode(node);
freeList.insertNodeFirst(node);
}
public:
// Get the node corresponding to an index
static ValuePtr getNode(int index)
{
return &array.getPtr(index).data.value;
}
// Get the index from a node
static int getIndex(ValuePtr node)
{
return ( cast(Node*)node ).index;
}
uint length() { return nodes.length; }
static uint totLength() { return array.length; }
// Move the given node to another list
ValuePtr moveTo(ref BufferList fl, ValuePtr node)
{
nodes.removeNode(node);
fl.nodes.insertNodeFirst(node);
return node;
}
// Get the first element in the list
ValuePtr getHead() { return &nodes.getHead().value; }
// Loop through the structs in this list
int opApply(int delegate(ref Value) dg)
{
return nodes.opApply(dg);
}
int[] getInt(int isize)
{
assert(isize <= ints);
return getNew().ints[0..isize];
}
void freeInt(int[] buf)
{
assert(buf.length <= ints);
remove(cast(ValuePtr)buf.ptr);
}
void* get() { return getNew(); }
void free(void* p) { remove(cast(ValuePtr)p); }
}
struct Buffers
{
static:
BufferList!(64) b64;
BufferList!(128) b128;
BufferList!(256) b256;
BufferList!(768) b768;
/*
static this()
{
writefln("64: ints=%s bytes=%s", b64.ints, b64.bytes);
writefln("128: ints=%s bytes=%s", b128.ints, b128.bytes);
writefln("256: ints=%s bytes=%s", b256.ints, b256.bytes);
writefln("768: ints=%s bytes=%s", b768.ints, b768.bytes);
}
*/
int[] getInt(uint size)
{
if(size <= b64.ints) return b64.getInt(size);
else if(size <= b128.ints) return b128.getInt(size);
else if(size <= b256.ints) return b256.getInt(size);
else if(size <= b768.ints) return b768.getInt(size);
// Too large for our lists - just use malloc
else
{
//writefln("WARNING: using malloc for %s ints (%s bytes)", size, size*int.sizeof);
return ( cast(int*)malloc(size*int.sizeof) )[0..size];
}
}
void free(int[] buf)
{
uint size = buf.length;
if(size <= b64.ints) b64.freeInt(buf);
else if(size <= b128.ints) b128.freeInt(buf);
else if(size <= b256.ints) b256.freeInt(buf);
else if(size <= b768.ints) b768.freeInt(buf);
else .free(buf.ptr);
}
}
/* THIS DOESN'T WORK - because DMD is still stubborn with those
template forwarding issues. Instead we'll just reuse the old
freelist implementation below.
// A list that uses a freelist for allocation. It is built on top of
// BufferList.
struct FreeList(T)
{
private:
// For small sizes, pool together with existing lists.
static if(T.sizeof <= 64) static const size = 64;
else static if(T.sizeof <= 128) static const size = 128;
else static if(T.sizeof <= 256) static const size = 256;
// Just use the actual size, rounded up to the nearest 16
else static if(T.sizeof % 16 == 0)
const size = T.sizeof;
else
const size = T.sizeof + 16 - (T.sizeof%16);
alias BufferList!(size) BuffList;
BuffList buffer;
alias BuffList.Value Value;
alias BuffList.ValuePtr ValuePtr;
static assert(T.sizeof <= BuffList.bytes);
public:
// Get a new node (move from freelist to node list)
T* getNew()
{ return cast(T*) buffer.get(); }
// Move a node back to the freelist ("delete" it)
void remove(T* node)
{ buffer.free(node); }
// Get the node corresponding to an index
static T* getNode(int index)
{ return cast(T*) buffer.getNode(index); }
// Get the index from a node
static int getIndex(T *node)
{ return buffer.getIndex(cast(ValuePtr)node); }
uint length() { return buffer.length(); }
static uint totLength() { return buffer.totLength(); }
// Move the given node to another list
T* moveTo(ref FreeList fl, T* node)
{
auto vp = cast(ValuePtr) node;
return cast(T*) buffer.moveTo(fl.buffer, vp);
}
// Get the first element in the list
T* getHead() { return cast(T*) buffer.getHead(); }
// Loop through the structs in this list
int opApply(int delegate(ref T) dg)
{
auto dgc = cast(int delegate(ref Value)) dg;
return nodes.opApply(dgc);
}
}
*/
// This had to be moved outside FreeList to work around some
// irritating DMD template problems. (Can you say Aaargh!)
struct __FreeNode(T)
{
_lstNode!(T) data;
int index;
}
// A list that uses a freelist for allocation. Based on
// LinkedList. Very basic, only functions that are actually in use in
// my own code are implemented.
struct FreeList(T)
{
alias LinkedList!(T, NoAlloc) TList;
alias TList.Node TNode;
private:
alias __FreeNode!(T) _FreeNode;
// This is the array that does all the actual allocations. It is
// used for quickly looking up indices.
static GrowArray!(_FreeNode) array;
// The freelist. This is shared between all template instances of
// the same type, as far as I know. DMD might have some strange
// behavior that I am not aware of, but the worst case is that we
// end up with multiple freelists, which is not the end of the world
// (although slightly inefficient.)
static TList freeList;
// The nodes belonging to THIS list
TList nodes;
public:
// Get a new node (move from freelist to node list)
T* getNew()
{
// Is the freelist empty?
if(freeList.length == 0)
{
// Create a bunch of nodes and shove them into the freelist.
const makeSize = 100;
// Grow the growarray
uint len = array.length;
array.length = len + makeSize;
// Loop through the new nodes, number them, and insert them
// into freeList
for(int i=0; i < makeSize; i++)
{
_FreeNode *fn = array.getPtr(i+len);
fn.index = i + len;
freeList.insertNode(&fn.data);
}
}
// Move the first element from the freelist into the node list.
auto node = freeList.getHead;
freeList.removeNode(node);
nodes.insertNodeFirst(node);
// Return the value pointer. Since the value is always at the
// begining of the Node struct, this is the same
// pointer. LinkedList lets us choose if we want to use T* or
// Node*.
return &node.value;
}
// Get the node corresponding to an index
static T* getNode(int index)
{
return &array.getPtr(index).data.value;
}
// Get the index from a node
static int getIndex(T *node)
{
return ( cast(_FreeNode*)node ).index;
}
// Move a node back to the freelist ("delete" it)
void remove(T* node)
{
nodes.removeNode(node);
freeList.insertNodeFirst(node);
}
uint length() { return nodes.length; }
static uint totLength() { return array.length; }
// Move the given node to another list
T* moveTo(ref FreeList fl, T* node)
{
nodes.removeNode(node);
fl.nodes.insertNodeFirst(node);
return node;
}
// Get the first element in the list
T* getHead() { return &nodes.getHead().value; }
// Get the next element in the list
T* getNext(T* nd)
{
auto node = cast(TNode*)nd;
return cast(T*) node.getNext();
}
// Loop through the structs in this list
int opApply(int delegate(ref T) dg)
{ return nodes.opApply(dg); }
}

312
old_d_version/monster/util/growarray.d
Unescape Escape View File

@ -1,312 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (growarray.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.util.growarray;
// Array that grows without reallocations. It does this by
// block-allocation and by stringing several blocks together to work
// like one single array. Elements are not guaranteed to be stored
// continuously in memory.
struct GrowArray(T)
{
const defSize = 128;
private:
uint listSize = defSize; // Size of new lists
uint elements; // Current number of elements
uint elemsAlloc; // Elements allocated
uint begin; // At what element to start counting. Used for
// slices.
T[][] listList;
// Make sure there is room for at least 'size' elements in total.
void alloc(uint size)
{
// Do nothing if the list is large enough
if(size <= elemsAlloc) return;
// If this is a slice, we must always reallocate when
// growing. Implement that later.
if(begin) assert(0, "Cannot grow a slice");
// Number of lists we need
uint lists = ((size-1) / listSize) + 1;
// The number of needed elements should never decrease
assert((listSize*lists) >= elemsAlloc);
// Number of elements we need allocated
elemsAlloc = listSize * lists;
// Make sure the list of lists is large enough
if(listList.length < lists)
listList.length = lists+30;
// Allocate the lists we need
for(int i=0; i<lists; i++)
listList[i].length = listSize;
}
public:
uint length() { return elements - begin; }
void length(uint newLen)
{
newLen += begin;
alloc(newLen);
elements = newLen;
}
// Initialize - set the current size
void initialize(uint size = 0, uint listSize = defSize)
{
assert(listList.length == 0);
this.listSize = listSize;
length(size);
}
static GrowArray opCall(uint size = 0, uint listSize = defSize)
{
GrowArray a;
a.initialize(size, listSize);
return a;
}
void opCatAssign(T t)
{
length = length + 1;
opIndexAssign(t, length-1);
}
void opCatAssign(T[] list)
{
uint len = length;
length = len + list.length;
foreach(int i, ref T t; list)
opIndexAssign(t, len+i);
}
T opIndex(int index)
{
index += begin;
assert(index >= begin && index < elements,
"GrowArray index out of bounds");
return listList[index/listSize][index%listSize];
}
T opIndexAssign(T value, int index)
{
index += begin;
assert(index >= begin && index < elements,
"GrowArray index out of bounds");
return (listList[index/listSize][index%listSize] = value);
}
T* getPtr(int index)
{
index += begin;
assert(index >= begin && index < elements,
"GrowArray index out of bounds");
return &listList[index/listSize][index%listSize];
}
GrowArray opSlice(int start, int stop)
{
assert(start<=stop, "Illegal GrowArray slice");
GrowArray ga = *this;
ga.begin = begin+start;
ga.length = stop-start;
return ga;
}
GrowArray opSlice()
{
return *this;
}
// Get a contiguous array copy containg all the elements.
T[] arrayCopy()
{
T[] res = new T[length()];
// Non-optimized!
foreach(i, ref r; res)
r = opIndex(i);
return res;
}
int opApply(int delegate(ref int, ref T) dg)
{
int res;
int len = length;
int pos = begin%listSize;
int list = begin/listSize;
for(int i; i<len; i++)
{
res = dg(i, listList[list][pos++]);
if(res) break;
if(pos == listSize)
{
list++;
pos = 0;
}
}
return res;
}
int opApply(int delegate(ref T) dg)
{
int res;
int len = length;
int pos = begin%listSize;
int list = begin/listSize;
for(int i; i<len; i++)
{
res = dg(listList[list][pos++]);
if(res) break;
if(pos == listSize)
{
list++;
pos = 0;
}
}
return res;
}
}
unittest
{
// Test default initialization
GrowArray!(int) arr;
assert(arr.begin == 0);
assert(arr.length == 0);
assert(arr.elements == 0);
assert(arr.elemsAlloc == 0);
assert(arr.listList.length == 0);
assert(arr.listSize == 128);
// Setting length
arr.length = 3;
assert(arr.length == 3);
assert(arr.elements == 3);
assert(arr.elemsAlloc == arr.listSize);
assert(arr.listList.length >= 1);
// Setting and reading elements
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
assert(arr[0] == 1);
assert(arr[1] == 2);
assert(arr[2] == 3);
assert(arr.listList[0][0] == 1);
assert(arr.listList[0][1] == 2);
assert(arr.listList[0][2] == 3);
// Test opCatAssign
arr ~= 4;
assert(arr.length == 4);
assert(arr[3] == 4);
// Foreach
int tmp = 0;
foreach(int i, int v; arr)
{
assert(v==i+1);
tmp++;
}
assert(tmp == 4);
tmp = 1;
foreach(int v; arr)
assert(v == tmp++);
assert(tmp == 5);
// Slicing the entire array
arr = arr[0..4];
assert(arr.length == 4);
assert(arr[3] == 4);
// Slicing part of the array
auto arrS = arr[1..3];
assert(arrS.length == 2);
assert(arrS[0] == 2);
assert(arrS[1] == 3);
arrS[0] = 10;
assert(arr[1] == 10);
// Slicing the slice
arrS = arrS[1..2];
assert(arrS.length == 1);
assert(arrS[0] == 3);
// Empty slice
arrS = arr[3..3];
assert(arrS.length == 0);
// Custom list size, and more than one list
auto arr2 = GrowArray!(byte)(3,2);
assert(arr2.length == 3);
assert(arr2.elements == 3);
assert(arr2.listSize == 2);
assert(arr2.elemsAlloc == 4);
assert(arr2.listList.length >= 2);
assert(arr2.listList[0].length == 2);
assert(arr2[0] == 0);
assert(arr2[1] == 0);
assert(arr2[2] == 0);
arr2[1]=2;
arr2[2]=4;
foreach(int i, byte v; arr2)
assert(v == 2*i);
// Check that boundry checking works (in non-release mode.)
bool err = false;
try{arr2[3];}
catch
{
err = true;
}
assert(err == true);
err = false;
try{arr2[3] = 0;}
catch
{
err = true;
}
assert(err == true);
}

641
old_d_version/monster/util/list.d
Unescape Escape View File

@ -1,641 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (list.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.util.list;
// Set this to enable some more extensive list checks. These will loop
// through the entire list on every insert and remove, so they are
// very slow for large lists. But they are very handy bug catchers
// when doing a little dirty list hacking.
// debug=slowcheck;
private import std.c.stdlib;
private import std.string;
typedef void GCAlloc;
alias malloc cmalloc;
alias free cfree;
class LinkedListException : Exception
{
this(char[] msg)
{
super(msg);
}
}
/*
* Internal structure used by List
*/
align(1)
struct _lstNode(Value)
{
// It is essential that the value is first in the struct. This
// allows us to interchange pointers to the value with pointer to
// the Node. This is done for convenience - allowing us to use the
// value directly instead of using somePtr.value, This also
// sidesteps the fact that DMD isn't very good with template forward
// references, something that creates a lot of problems if we use
// LinkedList.Iterator for everything (trust me on this.)
Value value;
_lstNode* getNext() { return next; }
_lstNode* getPrev() { return prev; }
private:
_lstNode* next; // Next node
_lstNode* prev; // Previous node
}
/*
* This is a doubly linked list. It's not terribly advanced at the
* moment, but I don't need any more functionality right now.
*
* Alloc must have the following members:
* void* alloc(uint size)
* void free(void*)
* bool autoinit; // True if alloc automatically sets memory to zero.
*/
// Example allocator using malloc and free:
struct Malloc
{
static const bool autoinit = false; // malloc does not initialize memory
static const bool usefree = true; // We must call free() to release memory
static void* alloc(uint size) { return cmalloc(size); }
static void free(void* p) { cfree(p); }
}
// A null allocator. Use if you only intend to move nodes into and out
// of the list, not to allocate them. Useful for a freelist, for
// example.
struct NoAlloc
{
static const bool autoinit = false;
static const bool usefree = true;
static void *alloc(uint size) { assert(0, "NoAlloc.alloc not allowed"); }
static void free(void *p) { assert(0, "NoAlloc.free not allowed"); }
}
struct LinkedList(Value, alias Alloc = GCAlloc)
{
alias _lstNode!(Value) Node;
private:
Node *head; // This is the head of the linked list (first element)
Node *tail; // New nodes are inserted here
uint totalNum; // Number of elements
// Determine if the allocator automatically initializes memory
static if(is(Alloc == GCAlloc))
static const bool autoinit = true;
else static if(Alloc.autoinit)
static const bool autoinit = true;
else
static const bool autoinit = false;
// Determine if we have to manually free memory
static if(is(Alloc == GCAlloc))
static const bool usefree = false;
else static if(Alloc.usefree)
static const bool usefree = true;
else
static const bool usefree = false;
// Throw an exception
void fail(char[] msg)
{
msg = format("LinkedList!(%s) exception: %s", typeid(Value).toString, msg);
throw new LinkedListException(msg);
}
public:
// Whenever you find a bug that creates an invalid state, put it in
// here so we can safeguard against regressions
invariant()
{
if(head != null || tail != null || totalNum != 0)
{
assert(head != null);
assert(tail != null);
assert(totalNum != 0);
assert(head.prev == null);
assert(tail.next == null);
}
}
alias Node* Iterator;
// Simply reset all pointers and variables, losing any nodes
// present.
void reset()
{
head = tail = null;
totalNum = 0;
}
// Go through the list and delete all nodes
void deleteAll()
{
// If there is no need to free objects, then deleteAll() is
// equivalent to reset().
static if(usefree)
{
// Loop through the list and delete everything
Node *p = head;
while(p != null)
{
Node *next = p.next;
Alloc.free(p);
p = next;
}
}
reset();
}
Iterator getHead() { return head; }
Iterator getTail() { return tail; }
// Check if the given iterator is part of the list
bool hasIterator(Node *v)
{
Node* p = head;
while(p != null)
{
if(p == v)
{
assert(length >= 1);
return true;
}
p = p.next;
}
return false;
}
// Insert a value at the end of the list.
alias insert insertLast;
Iterator insert(Value v)
{
Node *p = createNode();
p.value = v;
return insertNode(p);
}
// Also allow ~= syntax for this
Iterator opCatAssign(Value v) { return insert(v); }
// Insert an existing node at the end of the list. The insertNode*()
// variants along with removeNode() are useful for removing and
// reinserting nodes without allocating more memory. This can for
// example be used for free lists and similar constructions. In
// other words, you can use these to move elements from one list to
// another.
alias insertNode insertNodeLast;
Iterator insertNode(Node *p)
in
{
assert(!hasIterator(p), "inserNode: Node is already in the list");
}
body
{
if(tail)
{
// Insert node at the end of the list
assert(head != null);
tail.next = p;
}
else
{
// This is the first element to be inserted
assert(head == null);
head = p;
}
p.prev = tail;
tail = p;
p.next = null;
totalNum++;
return p;
}
// The Value* variants of the node functions work the same way as
// their Iterator (Node*) versions. The pointers are the same, they
// just need to be recast.
Value* insertNode(Value *p)
{ return &insertNode( cast(Node*)p ).value; }
// Beginning of the list
Iterator insertFirst(Value v)
{
Node *p = createNode();
p.value = v;
return insertNodeFirst(p);
}
Iterator insertNodeFirst(Node *p)
in
{
debug(slowcheck)
assert(!hasIterator(p), "inserNodeFirst: Node is already in the list");
}
body
{
if(head)
{
// Insert node at the beginning of the list
assert(tail != null);
head.prev = p;
}
else
{
// This is the first element to be inserted
assert(tail == null);
tail = p;
}
p.next = head;
head = p;
p.prev = null;
totalNum++;
return p;
}
Value* insertNodeFirst(Value *p)
{ return &insertNodeFirst( cast(Node*)p ).value; }
// Insert after a given element
Iterator insertAfter(Iterator i, Value v)
{
Node *p = createNode();
p.value = v;
return insertNodeAfter(i, p);
}
// Insert p after i
Iterator insertNodeAfter(Iterator i, Node *p)
in
{
//debug(slowcheck)
{
assert(!hasIterator(p), "inserNodeAfter: Node is already in the list");
assert(hasIterator(i), "insertNodeAfter(): element i not part of the list");
}
}
body
{
// If i is the last element, then insertNodeLast already does a
// stellar job of inserting
if(i == tail)
return insertNodeLast(p);
// Make p point to the right elements
p.next = i.next;
p.prev = i;
// Random consistency check
assert(i == i.next.prev);
// Make the right elements point to p
i.next = p;
assert(p.next != null);
p.next.prev = p;
totalNum++;
return p;
}
// Insert p after i
Value* insertNodeAfter(Value* p, Value* i)
{ return &insertNodeAfter( cast(Node*)p, cast(Node*)i ).value; }
// Insert value v before i
Iterator insertBefore(Iterator i, Value v)
{
Node *p = createNode();
p.value = v;
return insertNodeBefore(i, p);
}
// Insert p before i
Iterator insertNodeBefore(Iterator i, Node *p)
in
{
//debug(slowcheck)
{
assert(!hasIterator(p), "inserNodeBefore: Node is already in the list");
assert(hasIterator(i), "insertBefore(): element not part of the list");
}
}
body
{
// If i is the first, just insert at the beginning
if(i==head) return insertNodeFirst(p);
// If I mess it up, an assertion failure is easier to debug than
// a segfault.
assert(i.prev != null);
// Reuse insertAfter instead of reinventing the wheel
return insertNodeAfter(i.prev, p);
}
// Insert p before i
Value* insertNodeBefore(Value* p, Value* i)
{ return &insertNodeBefore( cast(Node*)p, cast(Node*)i ).value; }
// Swap position of element a and b
void swap(Iterator a, Iterator b)
in
{
//debug(slowcheck)
assert(hasIterator(a) && hasIterator(b),
"swap(a,b): both elements must be in the list");
}
body
{
Iterator tmp;
// Handle special cases first
// The same element? Do nothing.
if(a==b) return;
// Are they next to each other?
if(b.next == a)
{
// Swap it so we have a before b, then handle it below.
assert(a.prev == b);
tmp = a;
a = b;
b = tmp;
}
// Point a.prev to b
if(a.prev) a.prev.next = b;
else
{
assert(head == a);
head = b;
}
// Point to b.next a
if(b.next) b.next.prev = a;
else
{
assert(tail == b);
tail = a;
}
// From this point on, if a is next to b it must be handled as a
// special case. We have already swapped them above so that a is
// before b.
if(a.next == b)
{
assert(b.prev == a);
// Assign outer pointers
b.prev = a.prev;
a.next = b.next;
// Assign inner pointers
a.prev = b;
b.next = a;
return;
}
// If a is NOT next to b, continue the pointer orgy.
// Point a.next to b
if(a.next) a.next.prev = b;
else
{
assert(tail == a);
tail = b;
}
if(b.prev) b.prev.next = a;
else
{
assert(head == b);
head = a;
}
// Finally, swap a and b's internal pointers
tmp = a.next;
a.next = b.next;
b.next = tmp;
tmp = a.prev;
a.prev = b.prev;
b.prev = tmp;
}
void swap(Value* a, Value* b)
{ swap( cast(Node*)a, cast(Node*)b ); }
// Remove a node from the list and delete it
void remove(Iterator p)
{
removeNode(p);
deleteNode(p);
}
// Just remove the node from the list, do not delete it.
void removeNode(Iterator p)
in
{
//debug(slowcheck)
assert(hasIterator(p), "remove(): element not part of the list");
}
body
{
// Remove from the list
if(p.next)
{
p.next.prev = p.prev;
// Make sure we are NOT tail
assert(tail != p);
}
else // We're the tail
{
assert(tail == p);
tail = p.prev;
}
if(p.prev)
{
p.prev.next = p.next;
// We are NOT the head, since we have a previous element
assert(head != p);
}
else // We're head
{
assert(head == p);
head = p.next;
}
totalNum--;
}
void removeNode(Value *v)
{ removeNode( cast(Iterator)v ); }
// Free a node
static private void deleteNode(Node *p)
{
// For the GC, just release the
// pointer into the wild.
static if(usefree) Alloc.free(p);
}
// Create a new node and return it's pointer. TODO: Make this
// static, and increase totalNum in the insert methods instead.
static private Node* createNode()
{
static if(is(Alloc == GCAlloc))
Node *p = new Node;
else
Node *p = cast(Node*)Alloc.alloc(Node.sizeof);
// Initialize next pointers
static if(!autoinit)
{
p.next = null;
p.prev = null;
}
return p;
}
// Loop through the nodes in the order they were inserted
int opApply(int delegate(ref Value v) del)
{
Node *p = head;
uint safeGuard = 0;
while(p != null)
{
assert(safeGuard++ < totalNum);
int i = del(p.value);
if(i) return i;
p = p.next;
}
return 0;
}
// Loop through the nodes in the order they were inserted
int opApply(int delegate(ref int ind, ref Value v) del)
{
Node *p = head;
int ind = 0;
while(p != null)
{
assert(ind < totalNum);
int i = del(ind, p.value);
ind++;
if(i) return i;
p = p.next;
}
return 0;
}
// Number of elements
uint length() { return totalNum; }
char[] toString()
{
char[] res = "[";
foreach(int i, Value v; *this)
{
if(i < totalNum-1) res ~= format(" %s,", v);
else res ~= format(" %s ]", v);
}
return res;
}
}
alias LinkedList!(void*, NoAlloc) PointerList;
alias PointerList.Node vpNode;
alias PointerList.Iterator vpIter;
/* This test is NOT very complete */
unittest
{
LinkedList!(float) ll;
assert(ll.length == 0);
ll.Iterator it = ll.insert(10.4);
assert(ll.length == 1);
ll.insert(23);
it = ll.insert(6.3);
ll.insert(-1000);
assert(ll.length == 4);
//foreach(float f; ll) writefln(f);
ll.remove(it);
assert(ll.length == 3);
ll.reset();
assert(ll.length == 0);
//foreach(int i, float f; ll) writefln(i, " ", f);
}
//import std.stdio;
// Array allocator. TODO: Put this and Malloc in their own place,
// extend list to be the same quality as aa.d and make a system out of
// it. Make some better unit tests.
struct ArrAlloc
{
ubyte[] data;
uint pos;
void reset() { pos = 0; }
const bool autoinit = false;
const bool usefree = false;
void* alloc(uint size)
{
if(pos+size > data.length)
data.length = pos+size+30;
void * ptr = &data[pos];
pos += size;
return ptr;
}
void free(void* p) { }
}

114
old_d_version/monster/util/string.d
Unescape Escape View File

@ -1,114 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2004, 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (string.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.util.string;
import std.utf;
import std.string;
// These functions check whether a string begins or ends with a
// certain substring.
bool begins(char[] str, char[] start)
{
if(str.length < start.length ||
str[0..start.length] != start) return false;
return true;
}
bool ends(char[] str, char[] end)
{
if(str.length < end.length ||
str[$-end.length..$] != end) return false;
return true;
}
// Case insensitive versions of begins and ends
bool iBegins(char[] str, char[] start)
{
if(str.length < start.length ||
icmp(str[0..start.length], start) != 0) return false;
return true;
}
bool iEnds(char[] str, char[] end)
{
if(str.length < end.length ||
icmp(str[$-end.length..$], end) != 0) return false;
return true;
}
char[] nextWord(ref char[] str, char delim = ' ')
{
int i = find(str, delim);
char[] result;
// No 'delim' found, return the entire string and set remainder to
// null.
if(i == -1)
{
result = str;
str = null;
return result;
}
// A separator was found. Return everything upto 'delim' (index i),
// put the remainder of the string (not including the char at [i])
// in str.
result = str[0..i];
str = str[i+1..$];
return result;
}
// Strip trailing zeros
char[] stripz(char [] s)
{
foreach(int i, char c; s)
if( c == 0 )
return s[0..i];
return s;
}
// Convert a long integer into a string using nice comma
// formatting. delim is the delimiter character, size is the number of
// digits in each group. See the unittest for examples.
char[] comma(long i, char delim=',', int size = 3)
{
char[] str = toString(i);
char[] res;
if(i<0) str=str[1..$];
str.reverse;
foreach(int j, char c; str)
{
if(j!=0 && j%size == 0)
res = delim ~ res;
res = c ~ res;
}
if(i<0) res = "-" ~ res;
return res;
}

369
old_d_version/monster/vm/arrays.d
Unescape Escape View File

@ -1,369 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (arrays.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.arrays;
import monster.vm.stack;
import monster.util.freelist;
import monster.util.flags;
import monster.vm.error;
import monster.vm.mobject;
import std.string;
import std.uni;
import std.stdio;
import std.utf;
// An index to an array. Array indices may be 0, unlike object indices
// which span from 1 and upwards, and has 0 as the illegal 'null'
// reference. A null array will always refer to an empty array,
// because we insert an empty array at the first slot in the index
// list.
typedef int AIndex;
// Not all of these are used yet.
enum AFlags : int
{
None = 0x00,
Alive = 0x01, // This reference is not deleted
Const = 0x02, // Constant data
CanCollect = 0x04, // Can be colleted by the GC
RefCounted = 0x08, // Is reference counted
Marked = 0x10, // Was marked in the last GC sweep
Null = 0x20, // Is the null array
}
struct ArrayRef
{
union
{
int[] iarr;
float[] farr;
dchar[] carr;
AIndex[] aarr;
}
Flags!(AFlags) flags;
uint elemSize; // Size of each element (in ints)
AIndex getIndex()
{
return cast(AIndex)( Arrays.ArrayList.getIndex(this) );
}
// Array length, in terms of its element size
uint length()
{
if(isNull) return 0;
assert(elemSize != 0, "elemSize not set");
assert(iarr.length % elemSize == 0, "array length not divisible by element size");
return iarr.length / elemSize;
}
bool isAlive() { return flags.has(AFlags.Alive); }
bool isConst() { return flags.has(AFlags.Const); }
bool isNull() { return flags.has(AFlags.Null); }
}
Arrays arrays;
struct Arrays
{
alias FreeList!(ArrayRef) ArrayList;
private:
ArrayList arrList;
// Get a new array reference
ArrayRef *createArray()
{
ArrayRef *ar = arrList.getNew();
assert(!ar.isAlive);
// Set the "alive" flag
ar.flags.set(AFlags.Alive);
assert(!ar.isNull);
return ar;
}
// Put a reference back into the freelist
void destroyArray(ArrayRef *ar)
{
assert(ar.isAlive);
assert(!ar.isNull);
assert(!ar.isConst);
ar.flags.unset(AFlags.Alive);
arrList.remove(ar);
}
public:
// Set up this struct
void initialize()
{
// Make sure index zero is valid and is an empty array. Set
// more flags later.
auto ar = createArray();
ar.iarr = null;
ar.flags.set(AFlags.Null);
assert(ar.getIndex == 0);
}
// Get the reference to the empty array
ArrayRef *getZero()
{
return getRef(cast(AIndex)0);
}
ArrayRef *createT(T)(T[] data)
{
static if(T.sizeof == 4) return create(cast(int[])data, 1);
else static if(T.sizeof == 8) return create(cast(int[])data, 2);
else static assert(0);
}
alias createT!(int) create;
alias createT!(uint) create;
alias createT!(long) create;
alias createT!(ulong) create;
alias createT!(float) create;
alias createT!(double) create;
alias createT!(dchar) create;
alias createT!(AIndex) create;
alias createT!(MIndex) create;
ArrayRef *create(char[] arg)
{ return create(toUTF32(arg)); }
// Generic element size
ArrayRef *create(int[] data, int size)
{
assert(size > 0);
if(data.length == 0) return getZero();
ArrayRef *ar = createArray();
ar.iarr = data;
ar.elemSize = size;
if(data.length % size != 0)
fail("Array length not divisible by element size");
return ar;
}
ArrayRef *createConst(int[] data, int elem)
{
ArrayRef *arf = create(data, elem);
arf.flags.set(AFlags.Const);
return arf;
}
ArrayRef *getRef(AIndex index)
{
if(index < 0 || index >= getTotalArrays())
fail("Invalid array reference: " ~ toString(cast(int)index));
ArrayRef *arr = ArrayList.getNode(index);
if(!arr.isAlive)
fail("Dead array reference: " ~ toString(cast(int)index));
assert(arr.getIndex() == index);
if(index == 0) assert(arr.iarr.length == 0);
return arr;
}
// Get the number of array references in use
int getArrays()
{
return arrList.length();
}
// Get the total number of Array references ever allocated for the
// free list.
int getTotalArrays()
{
return ArrayList.totLength();
}
}
// Create a multi-dimensional array of rank 'rank' and innermost data
// initialized to 'initval'. The array lengths are popped of the
// script stack.
void createMultiDimArray(int rank, int init[])
{
if(rank <= 0 || rank >= 30)
fail("Invalid array nesting number " ~ toString(rank));
assert(init.length > 0);
int[30] lenbuf;
int[] lens = lenbuf[0..rank];
int[] data; // All the elements + overhead data
ulong totElem = 1; // Total number of elements. Set to 1 and
// multiplied with the length later.
ulong totSize = 0; // Total size of data to allocate
int[] currSlice; // Current slice of the data, used by getNext.
// Get the next 'count' ints of data, in the form of a newly created
// ArrayRef.
ArrayRef *getNext(int count, int elemSize=1)
{
assert(count <= currSlice.length);
int[] res = currSlice[0..count];
currSlice = currSlice[count..$];
return arrays.create(res, elemSize);
}
// Get the lengths, and calculate how much data we need. The first
// length is the outermost wrapper, the last is the number of
// actual elements in the innermost array wrapper.
foreach(int i, ref int len; lens)
{
len = stack.popInt();
// Do some sanity check on the length. The upper bound set here
// is pretty arbitrary, we might enlarge it later.
if(len <= 0 || len > 0x100000)
fail("Invalid array length " ~ toString(len));
// We could allow 0-length arrays here, but there's not much
// point really.
// Calculate in the element size in the last element
if(i == lens.length-1) len *= init.length;
// The total data is the cumulative value of totElem through all
// iterations. For example, if we have a k*m*n array, we must
// have k outer arrays, indexing a total of k*m subarrays,
// indexing a total of k*m*n elements. The total data size,
// assuming element sizes have been figured in, is
// k + k*m + k*m*n.
totElem *= len;
totSize += totElem;
}
// Allocate all the elements + overhead (data for the lookup arrays)
if(totSize)
{
assert(totElem >= 0 && totElem <= totSize);
// Let's slap a 10 meg sanity check on the total data size
if(totSize > 10*1024*1024)
fail("Total array size is too large: " ~ toString(totSize));
data.length = totSize;
// Set currSlice to point to the entire data
currSlice = data;
}
// Set up inner arrays recursively. This can be optimized heavily
// later (removing recursion, moving if-tests out of loops, avoiding
// double initialization, and so on.)
void setupArray(int lenIndex, ArrayRef *arr)
{
// Length of arrays at this level
int len = lens[lenIndex];
// Loop through the previous level and create the arrays of this level
foreach(ref AIndex ind; arr.aarr)
{
ArrayRef *narr;
if(lenIndex == rank-1)
// Remember to set the element size on the inner level
narr = getNext(len, init.length);
else
narr = getNext(len);
// Store the index or this array in the previous level
ind = narr.getIndex();
// Is this the innermost level?
if(lenIndex == rank-1)
{
// If so, this is an array of elements. Initialize them.
if(init.length == 1) narr.iarr[] = init[0];
else if(init.length == 2) (cast(long[])narr.iarr)[] = *(cast(long*)init.ptr);
else
for(int i=0; i<lens[0]; i+=init.length)
arr.iarr[i..i+init.length] = init[];
}
else
// If not, set up the indices in this array
setupArray(lenIndex+1, narr);
}
}
if(rank > 1)
{
// Create outer array and push it
ArrayRef *arr = getNext(lens[0]);
stack.pushArray(arr);
// Recursively set up the sub-arrays
setupArray(1, arr);
}
else
{
// Create outer array and push it. Element size has already been
// multiplied into the length.
ArrayRef *arr = getNext(lens[0], init.length);
stack.pushArray(arr);
// There is only one array level, so this IS the inner
// array. Initialize the elements. Optimize for element sizes 1
// and 2
if(init.length == 1) arr.iarr[] = init[0];
else if(init.length == 2) (cast(long[])arr.iarr)[] = *(cast(long*)init.ptr);
else
for(int i=0; i<lens[0]; i+=init.length)
arr.iarr[i..i+init.length] = init[];
}
// Make sure we used all the data!
assert(currSlice.length == 0);
}
// There's no phobos function that does unicode case insensitive
// string comparison, so let's make one ourselves. This can probably
// be optimized. toUniLower is in prinicple an expensive operation,
// but not so much if we assume most characters are ascii.
bool isUniCaseEqual(dchar[] a, dchar[] b)
{
if(a.length != b.length) return false;
foreach(int i, dchar ch; a)
if(ch != b[i] && toUniLower(ch) != toUniLower(b[i]))
return false;
return true;
}

98
old_d_version/monster/vm/codestream.d
Unescape Escape View File

@ -1,98 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (codestream.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.codestream;
import std.string;
import std.stdio;
import monster.vm.error;
// CodeStream is a simple utility structure for reading data
// sequentially. It holds a piece of byte compiled code, and keeps
// track of the position within the code.
struct CodeStream
{
private:
ubyte[] data;
int len;
ubyte *pos;
public:
void setData(ubyte[] data)
{
this.data = data;
len = data.length;
pos = data.ptr;
}
// Called when the end of the stream was unexpectedly encountered
void eos(char[] func)
{
char[] res = format("Premature end of input: %s() missing %s byte(s)",
func, -len);
fail(res);
}
// Jump to given position
void jump(int newPos)
{
if(newPos<0 || newPos>=data.length)
fail("Jump out of range");
len = data.length - newPos;
pos = &data[newPos];
}
// Get the current position
int getPos()
{
return pos-data.ptr;
}
ubyte get()
{
if(len--) return *(pos++);
eos("get");
}
int getInt()
{
len -= 4;
if(len < 0) eos("getInt");
int i = *(cast(int*)pos);
pos+=4;
return i;
}
// Get a slice of the 'size' next ints
int[] getIntArray(uint size)
{
size *=4; // Convert size to bytes
len -= size;
if(len < 0) eos("getArray");
int[] res = cast(int[])pos[0..size];
pos += size;
return res;
}
}

162
old_d_version/monster/vm/dbg.d
Unescape Escape View File

@ -1,162 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (dbg.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.dbg;
import monster.vm.thread;
import std.stream;
import std.string;
import std.cstream;
import monster.vm.fstack;
import monster.options;
/*
This file is used for runtime debugging, stack tracing, etc.
*/
/*
Create a trace for your function that automatically pops itself of
the fstack when it goes out of scope. Usage:
auto scope _t = new MTrace("funcName");
This is one of the few places where C++ is actually easier to use...
An alternative way to do the same thing:
dbg.trace("funcName");
scope(exit) dbg.untrace();
*/
scope class MTrace
{
this(char[] str) { dbg.trace(str); }
~this() { dbg.untrace(); }
}
Dbg dbg;
struct Dbg
{
Stream dbgOut = null;
// Add indentation for each function stack level (only works if
// logFStack is true in options.d)
char[] logLevelString = "| ";
// Called at startup
void init()
{
static if(defaultLogToStdout)
enableStdout();
}
void enableStdout()
{
dbgOut = dout;
}
void log(char[] msg, Thread *tr = null)
{
if(dbgOut !is null)
{
int logLevel = getFStackLevel();
int extLevel = getExtLevel();
int trdIndex = getThreadIndex(tr);
char[] str = format("(trd=%s,ext=%s,lev=%s)",
trdIndex,
extLevel,
logLevel);
str = format("%-24s", str);
dbgOut.writeString(str);
// If we're logging function stack activity, put in some fancy
// indentation as well.
static if(logFStack)
{
for(int i;i<logLevel+extLevel;i++)
dbgOut.writeString(logLevelString);
}
dbgOut.writeLine(msg);
}
}
// Stack tracing functions. These might be used internally in the
// engine, so they should not be disabled.
// Add an external function to the stack
void trace(char[] name)
{
getFStack().pushExt(name);
}
// Pop the last function pushed by trace()
void untrace()
{
auto fs = getFStack();
assert(fs.cur !is null && fs.cur.isExternal,
"vm.untrace() used on a non-external function stack entry");
fs.pop();
}
// Return the current function stack printout
char[] getTrace()
{ return getFStack().toString(); }
private:
int getExtLevel()
{
return externals.list.length;
}
int getFStackLevel()
{
if(cthread !is null)
return cthread.fstack.list.length;
return 0;
}
int getThreadIndex(Thread *tr = null)
{
if(tr !is null)
return tr.getIndex();
else if(cthread !is null)
return cthread.getIndex();
else return 0;
}
// Get the active function stack, or the externals stack if no
// thread is active.
FunctionStack *getFStack()
{
if(cthread !is null)
{
assert(!cthread.fstack.isEmpty);
return &cthread.fstack;
}
return &externals;
}
}

69
old_d_version/monster/vm/error.d
Unescape Escape View File

@ -1,69 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (error.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.error;
import monster.compiler.tokenizer;
version(Tango) import tango.core.Exception;
import std.string;
class MonsterException : Exception
{
this(char[] msg) { super(/*"MonsterException: " ~*/ msg); }
}
// Source file location
struct Floc
{
int line = -1;
char[] fname;
char[] toString() { return format("%s:%s", fname, line); }
}
void fail(char[] msg, Floc loc)
{
fail(msg, loc.fname, loc.line);
}
void fail(char[] msg, char[] fname, int line)
{
if(line != -1)
fail(format("%s:%s: %s", fname, line, msg));
else
fail(msg);
}
void fail(char[] msg)
{
throw new MonsterException(msg);
}
void fail(char[] msg, TokenArray toks)
{
if(toks.length)
fail(msg ~ ", found " ~ toks[0].str, toks[0].loc);
else
fail(msg ~ ", found end of file");
}

389
old_d_version/monster/vm/fstack.d
Unescape Escape View File

@ -1,389 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (fstack.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.fstack;
import monster.vm.codestream;
import monster.vm.mobject;
import monster.vm.mclass;
import monster.vm.stack;
import monster.vm.error;
import monster.vm.thread;
import monster.vm.dbg;
import monster.compiler.states;
import monster.compiler.functions;
import monster.compiler.linespec;
import monster.options;
import monster.util.freelist;
import std.stdio;
import std.string;
// "friendly" parameter and stack handling.
enum SPType
{
Function, // A function (script or native)
Idle, // Idle function
State, // State code
External, // An external function represented on the function stack
}
// One entry in the function stack
struct StackPoint
{
CodeStream code; // The byte code handler
union
{
Function *func; // What function we are in (if any)
State *state; // What state the function belongs to (if any)
char[] extName; // Name of external function
}
SPType ftype;
MonsterObject *obj; // "this"-pointer for the function
// Get the class owning the function
MonsterClass getCls()
{
assert(isFunc || isState);
assert(func !is null);
return func.owner;
}
bool isStatic()
{ return isFunc() && func.isStatic; }
bool isFunc()
{ return (ftype == SPType.Function) || (ftype == SPType.Idle); }
bool isState()
{ return ftype == SPType.State; }
bool isIdle()
{ return ftype == SPType.Idle; }
bool isNative()
{ return isFunc && func.isNative; }
bool isNormal()
{ return isState || (isFunc && func.isNormal); }
bool isExternal()
{ return ftype == SPType.External; }
// Get the current source position (file name and line
// number). Mostly used for error messages.
Floc getFloc()
{
assert(isFunc || isState);
Floc fl;
fl.fname = getCls().name.loc.fname;
// Subtract one to make sure we get the last instruction executed,
// not the next.
int pos = code.getPos() - 1;
if(pos < 0) pos = 0;
if(isFunc)
fl.line = findLine(func.lines, pos);
else
fl.line = findLine(state.lines, pos);
return fl;
}
char[] toString()
{
if(isExternal)
return "external " ~ extName;
assert(func !is null);
char[] type, cls, name;
cls = getCls().name.str;
if(isState)
{
type = "state";
name = state.name.str;
}
else
{
assert(isFunc);
name = func.name.str;
if(isIdle) type = "idle";
else if(isNormal) type = "script";
else if(isNative) type = "native";
else assert(0);
}
// Function location and name
return format("%s %s.%s", type, cls, name);
}
}
alias FreeList!(StackPoint) StackList;
alias StackList.TNode *StackNode;
// External functions that are pushed when there is no active
// thread. These will not prevent any future thread from being put in
// the background.
FunctionStack externals;
struct FunctionStack
{
private:
// Number of native functions on the stack
int natives;
public:
StackList list;
// The current entry
StackPoint *cur = null;
// Consistancy checks
invariant()
{
if(cur !is null)
{
assert(list.length > 0);
if(cur.ftype == SPType.State)
assert(list.length == 1);
}
else assert(list.length == 0);
}
// Get the thread associated with this function stack. Depends on
// the fact that we are the first member of the Thread, so our
// pointers are the same. If this changes, you MUST change this
// function as well.
Thread *getThread()
{
return cast(Thread*)this;
}
// Used for debug logging
void log(char[] msg)
{
static if(logFStack)
{
dbg.log(msg, getThread());
}
}
void killAll()
{
natives = 0;
while(list.length)
{
assert(cur !is null);
list.remove(cur);
cur = list.getHead();
}
assert(cur is null);
}
bool hasNatives() { return natives != 0; }
// Check if the function calling us is a normal function
bool isNormal()
{
return cur !is null && cur.isNormal;
}
// Is the function stack empty?
bool isEmpty() { return cur is null; }
bool isIdle() { return cur !is null && cur.ftype == SPType.Idle; }
// Are we currently running state code?
bool isStateCode() { return list.length == 1 && cur.ftype == SPType.State; }
// Sets up the next stack point and assigns the given object
private void push(MonsterObject *obj)
{
if(list.length >= maxFStack)
fail("Function stack overflow - infinite recursion?");
assert(cur is null || !cur.isIdle,
"Cannot call other script functions from an idle function");
// Puts a new node at the beginning of the list
cur = list.getNew();
cur.obj = obj;
}
// Set the stack point up as a function. Allows obj to be null.
void push(Function *func, MonsterObject *obj)
{
push(obj);
assert(func !is null);
cur.ftype = SPType.Function;
cur.func = func;
assert(func.owner !is null);
assert(obj is null || func.owner.parentOf(obj.cls));
// Point the code stream to the byte code, if any.
if(func.isNormal)
cur.code.setData(func.bcode);
else if(func.isNative)
natives++;
assert(!func.isIdle, "don't use fstack.push() on idle functions");
static if(logFStack)
{
log("+++ " ~ cur.toString());
}
}
// Set the stack point up as a state
void push(State *st, MonsterObject *obj)
{
assert(st !is null);
assert(isEmpty,
"state code can only run at the bottom of the function stack");
push(obj);
cur.ftype = SPType.State;
cur.state = st;
assert(obj !is null);
assert(st.owner !is null);
assert(st.owner.parentOf(obj.cls));
// Set up the byte code
cur.code.setData(st.bcode);
static if(logFStack)
{
log("+++ " ~ cur.toString());
}
}
// Push an external (non-scripted) function on the function
// stack.
void pushExt(char[] name)
{
push(null);
natives++;
cur.ftype = SPType.External;
cur.extName = name;
static if(logFStack)
{
log("+++ " ~ cur.toString());
}
}
void pushIdle(Function *func, MonsterObject *obj)
{
push(obj);
assert(func !is null);
cur.func = func;
cur.ftype = SPType.Idle;
assert(func.owner !is null);
assert(obj is null || func.owner.parentOf(obj.cls));
assert(func.isIdle, func.name.str ~ "() is not an idle function");
static if(logFStack)
{
log("+++ " ~ cur.toString());
}
}
// Pops one entry of the stack. Checks that the stack level has been
// returned to the correct position.
void pop()
{
if(isEmpty)
fail("Function stack underflow");
assert(list.length >= 1);
if(cur.isNative || cur.isExternal)
natives--;
assert(natives >= 0);
static if(logFStack)
{
log(" -- " ~ cur.toString());
}
// Remove the topmost node from the list, and set cur.
assert(cur == list.getHead());
list.remove(cur);
cur = list.getHead();
assert(list.length != 0 || cur is null);
static if(logFStack)
{
log("");
}
}
// Get a stack trace (pretty basic at the moment)
char[] toString()
{
char[] res;
int i;
foreach(ref c; list)
{
char[] msg;
if(i == 0)
msg = " (<---- current function)";
else if(i == list.length-1)
msg = " (<---- first Monster function)";
res ~= c.toString ~ msg ~ '\n';
i++;
}
// If we're not the externals list, add that one too
i = 0;
if(this !is &externals)
{
foreach(ref c; externals.list)
{
char[] msg;
if(i == externals.list.length-1)
msg = " (<---- first external function)";
res ~= c.toString ~ msg ~ '\n';
i++;
}
}
return "Trace:\n" ~ res;
}
}

26
old_d_version/monster/vm/gc.d
Unescape Escape View File

@ -1,26 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (gc.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// This file will eventually contain the garbage collector.
module monster.vm.gc;

81
old_d_version/monster/vm/idlefunction.d
Unescape Escape View File

@ -1,81 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (idlefunction.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.idlefunction;
import monster.vm.thread;
// Idle scheduling actions - returned from initiate()
enum IS
{
Poll, // Poll the hasFinished function regularily
Return, // Return to the thread immediately - reenter() is called
// first
Kill, // Kill the thread
Manual, // Handle the scheduling ourselves. We have to schedule
// or move the thread to another ThreadList before the
// end of initiate()
}
// A callback class for idle functions. A child object of this class
// is what you "bind" to idle functions (rather than just a delegate,
// like for native functions.) Note that instances are not bound to
// specific script objects or threads; one idle function instance may
// be called for many objects / threads simultaneously. Any data
// specific to this call (such as parameters) must be stored
// elsewhere, usually within the Thread.
abstract class IdleFunction
{
// This is called immediately after the idle function is "called"
// from M script. It has to handle function parameters (remove them
// from the stack), but otherwise does not have to do
// anything. Return true if the scheduler should put this idle
// function into the condition list, which is usually a good
// idea. For functions which never "return", and for event driven
// idle functions (which handle their own scheduling), you should
// return false.
abstract IS initiate(Thread*);
// This is called whenever the idle function is about to "return" to
// state code. It has to push the return value, if any, but
// otherwise it can be empty. Note that if the idle function is
// aborted (eg. the state is changed), this function is never
// called, and abort() is called instead.
void reentry(Thread*) {}
// Called whenever an idle function is aborted, for example by a
// state change. No action is usually required.
void abort(Thread*) {}
// The condition that determines if this function has finished. This
// is the main method by which the scheduler determines when to
// reenter M state code. For example, for an idle function
// waitSoundFinish(), this would return false if the sound is still
// playing, and true if the sound has finished. If you want a purely
// event-driven idle function (rather than polling each frame), you
// should return false in initiate and instead reschedule the object
// manually when the event occurs. (A nice interface for this has
// not been created yet, though.)
bool hasFinished(Thread*) { assert(0, "empty hasFinished()"); }
}

150
old_d_version/monster/vm/init.d
Unescape Escape View File

@ -1,150 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (init.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// This module makes sure that the library is initialized in all
// cases.
module monster.vm.init;
import monster.compiler.tokenizer;
import monster.compiler.properties;
import monster.compiler.scopes;
import monster.vm.thread;
import monster.vm.stack;
import monster.vm.mclass;
import monster.vm.arrays;
import monster.vm.vm;
import monster.vm.dbg;
import monster.modules.all;
import monster.options;
version(Tango)
{}
else
{
// D runtime stuff
version(Posix)
{
extern (C) void _STI_monitor_staticctor();
//extern (C) void _STD_monitor_staticdtor();
extern (C) void _STI_critical_init();
//extern (C) void _STD_critical_term();
}
version(Win32)
{
extern (C) void _minit();
}
extern (C) void gc_init();
//extern (C) void gc_term();
extern (C) void _moduleCtor();
//extern (C) void _moduleDtor();
extern (C) void _moduleUnitTests();
//extern (C) bool no_catch_exceptions;
} // end version(Tango) .. else
bool initHasRun = false;
bool stHasRun = false;
static this()
{
assert(!stHasRun);
stHasRun = true;
// While we're here, run the initializer right away if it hasn't run
// already.
if(!initHasRun)
doMonsterInit();
}
void doMonsterInit()
{
// Prevent recursion
assert(!initHasRun, "doMonsterInit should never run more than once");
initHasRun = true;
// First check if D has been initialized.
if(!stHasRun)
{
// Nope. This is normal though if we're running as a C++
// library. We have to init the D runtime manually.
// But this is not supported in Tango at the moment.
version(Tango)
{
assert(0, "tango-compiled C++ library not supported yet");
}
else
{
version (Posix)
{
_STI_monitor_staticctor();
_STI_critical_init();
}
gc_init();
version (Win32)
{
_minit();
}
_moduleCtor();
_moduleUnitTests();
}
}
assert(stHasRun, "D library initializion failed");
// Next, initialize the Monster library
// Initialize the debugger structure
dbg.init();
// Initialize tokenizer
initTokenizer();
// initScope depends on doVMInit setting vm.vfs
vm.doVMInit();
initScope();
// The rest of the VM
scheduler.init();
stack.init();
arrays.initialize();
// Compiles the 'Object' class
MonsterClass.initialize();
// Depends on 'Object'
initProperties();
// Load modules
static if(loadModules)
initAllModules();
}

281
old_d_version/monster/vm/iterators.d
Unescape Escape View File

@ -1,281 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (iterators.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.iterators;
import monster.util.freelist;
import monster.vm.error;
import monster.vm.arrays;
import monster.vm.mclass;
import monster.vm.mobject;
import monster.util.flags;
import std.string;
import std.stdio;
// An iterator index.
typedef int IIndex;
// Flags for iterator structs
enum IFlags
{
None = 0x00,
Alive = 0x01, // This reference is not deleted
}
struct IteratorRef
{
Flags!(IFlags) flags;
ArrayRef *array;
int index; // TODO: Might not be necessary to keep a local copy of this
int indexMul; // Index multiplied with element size
int elemSize;
int *sindex; // Index on the stack
int[] sval; // Value on the stack
bool isReverse, isRef;
bool isClass;
MonsterObject *mo;
MonsterClass mc;
// Array iterators
bool firstArray(bool irev, bool iref, int *stk)
{
isRef = iref;
isReverse = irev;
isClass = false;
// Replace the array index on the stack
AIndex ai = cast(AIndex)*stk;
*stk = cast(int) getIndex();
// Fetch the array
array = arrays.getRef(ai);
// Cannot use reference values on const arrays
if(array.isConst && isRef)
// TODO: Try to give line and file in all messages
fail("Cannot use 'ref' values with constant arrays");
// Skip the loop if it's empty
if(array.iarr.length == 0) return false;
assert(array.elemSize > 0);
elemSize = array.elemSize;
// Point to the stack index and value
stk -= elemSize;
sval = stk[0..elemSize];
stk--;
sindex = stk;
// Set up the first element
if(isReverse) index = array.length-1;
else index = 0;
indexMul = index * elemSize;
*sindex = index;
sval[] = array.iarr[indexMul..indexMul+elemSize];
return true;
}
// Class iterators
bool firstClass(MonsterClass mc, int[] stk)
{
assert(stk.length == 2);
isClass = true;
// Set the iterator index on the stack
stk[1] = cast(int) getIndex();
mo = mc.getFirst();
this.mc = mc;
// Are there any objects?
if(mo == null) return false;
sindex = &stk[0];
*sindex = cast(int)mo.getIndex();
return true;
}
void storeRef()
{
assert(!isClass);
if(isRef)
array.iarr[indexMul..indexMul+elemSize] = sval[];
else
fail("Array iterator update called on non-ref parameter");
}
bool next()
{
// Handle class iterations seperately
if(isClass)
{
mo = mc.getNext(mo);
if(mo == null) return false;
*sindex = cast(int)mo.getIndex();
return true;
}
if(isReverse)
{
index--;
indexMul -= elemSize;
if(index == -1) return false;
}
else
{
index++;
indexMul += elemSize;
if(index*elemSize == array.iarr.length) return false;
}
assert(indexMul < array.iarr.length);
assert(index >= 0 && index < array.length);
assert(indexMul == index*elemSize);
*sindex = index;
sval[] = array.iarr[indexMul..indexMul+elemSize];
return true;
}
IIndex getIndex()
{
return cast(IIndex)( Iterators.IterList.getIndex(this) );
}
bool isAlive() { return flags.has(IFlags.Alive); }
}
Iterators iterators;
struct Iterators
{
alias FreeList!(IteratorRef) IterList;
private:
IterList iterList;
// Get a new iterator reference
IteratorRef *createIterator()
{
IteratorRef *it = iterList.getNew();
assert(!it.isAlive);
// Set the "alive" flag
it.flags.set(IFlags.Alive);
return it;
}
// Put a reference back into the freelist
void destroyIterator(IteratorRef *it)
{
assert(it.isAlive);
it.flags.unset(IFlags.Alive);
iterList.remove(it);
}
public:
bool firstArray(bool irev, bool iref, int *stk)
{
IteratorRef *it = createIterator();
bool res = it.firstArray(irev,iref,stk);
// Kill the iterator reference if we are done iterating
if(!res) destroyIterator(it);
return res;
}
bool firstClass(MonsterClass mc, int[] stk)
{
IteratorRef *it = createIterator();
bool res = it.firstClass(mc,stk);
// Kill the iterator reference if we are done iterating
if(!res) destroyIterator(it);
return res;
}
bool next(IIndex ind)
{
IteratorRef *it = getRef(ind);
bool res = it.next();
// Kill the iterator reference if this was the last iteration
if(!res) destroyIterator(it);
return res;
}
void stop(IIndex ind)
{
IteratorRef *it = getRef(ind);
destroyIterator(it);
}
void update(IIndex ind)
{
IteratorRef *it = getRef(ind);
it.storeRef();
}
IteratorRef *getRef(IIndex index)
{
if(index < 0 || index >= getTotalIterators())
fail("Invalid iterator reference: " ~ toString(cast(int)index));
IteratorRef *itr = IterList.getNode(index);
if(!itr.isAlive)
fail("Dead iterator reference: " ~ toString(cast(int)index));
assert(itr.getIndex() == index);
return itr;
}
// Get the number of iterator references in use
int getIterators()
{
return iterList.length();
}
// Get the total number of Iterator references ever allocated for the
// free list.
int getTotalIterators()
{
return IterList.totLength();
}
}

1418
old_d_version/monster/vm/mclass.d
View File

File diff suppressed because it is too large Load Diff

484
old_d_version/monster/vm/mobject.d
Unescape Escape View File

@ -1,484 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (mobject.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.mobject;
import monster.vm.thread;
import monster.vm.error;
import monster.vm.mclass;
import monster.vm.arrays;
import monster.vm.stack;
import monster.util.freelist;
import monster.util.list;
import monster.compiler.states;
import monster.compiler.variables;
import monster.compiler.scopes;
import monster.compiler.functions;
import std.string;
import std.stdio;
import std.utf;
// An index to a monster object.
typedef int MIndex;
union SharedType
{
int i;
uint ui;
long l;
ulong ul;
float f;
double d;
void *vptr;
Object obj;
}
struct ExtraData
{
SharedType extra;
vpNode node;
}
struct MonsterObject
{
/*******************************************************
* *
* Public variables *
* *
*******************************************************/
MonsterClass cls;
// Thread used for running state code. May be null if no code is
// running or scheduled.
Thread *sthread;
// The following variables are "tree-indexed". This means that
// they're arrays, with one element for each class in the
// inheritance hierarchy. The corresponding class tree can be found
// in cls.tree.
// Object data segment.
int[][] data;
/*******************************************************
* *
* Private variables *
* *
*******************************************************/
//private:
State *state; // Current state, null is the empty state.
public:
/*******************************************************
* *
* Functions for object handling *
* *
*******************************************************/
// Get the index of this object
MIndex getIndex()
{
return cast(MIndex)( ObjectList.getIndex(this)+1 );
}
// Delete this object. Do not use the object after calling this
// function.
void deleteSelf()
{
cls.deleteObject(this);
}
// Create a clone of this object.
MonsterObject *clone()
{ return cls.createClone(this); }
/*******************************************************
* *
* Member variable getters / setters *
* *
*******************************************************/
// The last two ints of the data segment can be used to store extra
// data associated with the object. A typical example is the pointer
// to a D/C++ struct or class counterpart to the Monster class.
static const exSize = ExtraData.sizeof / int.sizeof;
static assert(exSize*4 == ExtraData.sizeof);
SharedType *getExtra(int index)
{
return & (cast(ExtraData*)&data[index][$-exSize]).extra;
}
SharedType *getExtra(MonsterClass mc)
{ return getExtra(cls.upcast(mc)); }
// This is the work horse for all the set/get functions.
T* getPtr(T)(char[] name)
{
// Find the variable
Variable *vb = cls.findVariable(name);
assert(vb !is null);
// Check the type
if(!vb.type.isDType(typeid(T)))
{
char[] request;
static if(is(T == dchar)) request = "char"; else
static if(is(T == AIndex)) request = "array"; else
static if(is(T == MIndex)) request = "object"; else
request = typeid(T).toString();
fail(format("Requested variable %s is not the right type (wanted %s, found %s)",
name, request, vb.type.toString()));
}
// Cast the object to the right kind
assert(vb.sc.isClass(), "variable must be a class variable");
MonsterClass mc = vb.sc.getClass();
assert(mc !is null);
// Return the pointer
return cast(T*) getDataInt(mc.treeIndex, vb.number);
}
T getType(T)(char[] name)
{ return *getPtr!(T)(name); }
void setType(T)(char[] name, T t)
{ *getPtr!(T)(name) = t; }
alias getPtr!(int) getIntPtr;
alias getPtr!(uint) getUintPtr;
alias getPtr!(long) getLongPtr;
alias getPtr!(ulong) getUlongPtr;
alias getPtr!(bool) getBoolPtr;
alias getPtr!(float) getFloatPtr;
alias getPtr!(double) getDoublePtr;
alias getPtr!(dchar) getCharPtr;
alias getPtr!(AIndex) getAIndexPtr;
alias getPtr!(MIndex) getMIndexPtr;
alias getType!(int) getInt;
alias getType!(uint) getUint;
alias getType!(long) getLong;
alias getType!(ulong) getUlong;
alias getType!(bool) getBool;
alias getType!(float) getFloat;
alias getType!(double) getDouble;
alias getType!(dchar) getChar;
alias getType!(AIndex) getAIndex;
alias getType!(MIndex) getMIndex;
alias setType!(int) setInt;
alias setType!(uint) setUint;
alias setType!(long) setLong;
alias setType!(ulong) setUlong;
alias setType!(bool) setBool;
alias setType!(float) setFloat;
alias setType!(double) setDouble;
alias setType!(dchar) setChar;
alias setType!(AIndex) setAIndex;
alias setType!(MIndex) setMIndex;
MonsterObject *getObject(char[] name)
{ return getMObject(getMIndex(name)); }
void setObject(char[] name, MonsterObject *obj)
{ setMIndex(name, obj.getIndex()); }
// Array stuff
ArrayRef* getArray(char[] name)
{ return arrays.getRef(getAIndex(name)); }
void setArray(char[] name, ArrayRef *r)
{ setAIndex(name,r.getIndex()); }
char[] getString8(char[] name)
{ return toUTF8(getArray(name).carr); }
void setString8(char[] name, char[] str)
{ setArray(name, arrays.create(toUTF32(str))); }
/*******************************************************
* *
* Lower level member data functions *
* *
*******************************************************/
// Get an int from the data segment
int *getDataInt(int treeIndex, int pos)
{
assert(treeIndex >= 0 && treeIndex < data.length,
"tree index out of range: " ~ .toString(treeIndex));
assert(pos >= 0 && pos<data[treeIndex].length,
"data pointer out of range: " ~ .toString(pos));
return &data[treeIndex][pos];
}
// Get an array from the data segment
int[] getDataArray(int treeIndex, int pos, int len)
{
assert(len > 0);
assert(treeIndex >= 0 && treeIndex < data.length,
"tree index out of range: " ~ .toString(treeIndex));
assert(pos >= 0 && (pos+len)<=data[treeIndex].length,
"data pointer out of range: pos=" ~ .toString(pos) ~
", len=" ~.toString(len));
return data[treeIndex][pos..pos+len];
}
/*******************************************************
* *
* Calling functions and setting states *
* *
*******************************************************/
// Call a named function directly. The function is executed
// immediately, and call() returns when the function is
// finished. The function is called virtually, so any child class
// function that overrides it will take precedence. This is the 'low
// level' way to call functions, meaning that you have to handle
// parameters and return values on the stack manually. Use the
// template functions below for a more high level interface.
void call(char[] name)
{
cls.findFunction(name).call(this);
}
template callT(T)
{
T callT(A ...)(char[] name, A a)
{
return cls.findFunction(name).callT!(T)(this, a);
}
}
alias callT!(void) callVoid;
alias callT!(int) callInt;
alias callT!(uint) callUint;
alias callT!(float) callFloat;
alias callT!(double) callDouble;
alias callT!(long) callLong;
alias callT!(ulong) callUlong;
alias callT!(dchar) callChar;
alias callT!(MIndex) callMIndex;
alias callT!(AIndex) callAIndex;
// Create a paused thread that's set up to call the given
// function. It must be started with Thread.call() or
// Thread.restart().
Thread *thread(char[] name)
{ return thread(cls.findFunction(name)); }
Thread *thread(Function *fn)
{
assert(fn !is null);
if(fn.paramSize > 0)
fail("thread(): function " ~ fn.name.str ~ " cannot have parameters");
fn = fn.findVirtual(this);
Thread *trd = Thread.getNew();
// Schedule the function to run the next frame
trd.pushFunc(fn, this);
assert(trd.isPaused);
assert(trd.fstack.cur !is null);
return trd;
}
// Create a thread containing the function and schedule it to start
// the next frame
Thread *start(char[] name)
{ return start(cls.findFunction(name)); }
Thread *start(Function *fn)
{
assert(fn !is null);
auto trd = thread(fn);
trd.restart();
return trd;
}
/* Set state. Invoked by the statement "state = statename;". This
function can be called in several situations, with various
results:
+ setState called with current state, no label
-> no action is performed
+ setState called with another state
+ setState called with current state + a label
-> state is changed normally
If a state change takes place directly in state code, the code is
aborted immediately. If it takes place in a function called from
state code, then code flow is allowed to return normally back to
the state code level, but is aborted immediately once it reaches
state code.
State changes outside state code will always unschedule any
previously scheduled code (such as idle functions, or previous
calls to setState.)
*/
void setState(State *st, StateLabel *label)
{
// Does the state actually change?
if(st !is state)
{
// Set the state
state = st;
// We must handle state functions and other magic here.
}
// If no label is specified and we are already in this state, then
// don't do anything.
else if(label is null) return;
// Do we already have a thread?
if(sthread !is null)
{
// Check if the thread has gone and died on us while we were
// away.
if(sthread.isDead)
sthread = null;
else
// Still alive. Stop any execution of the thread
sthread.stop();
}
// If we are jumping to anything but the empty state, we will have
// to schedule some code.
if(st !is null)
{
// Check that this state is valid
assert(st.owner.parentOf(cls), "state '" ~ st.name.str ~
"' is not part of class " ~ cls.getName());
if(label is null)
// Use the 'begin:' label, if any. It will be null there's
// no begin label.
label = st.begin;
if(label !is null)
{
// Make sure there's a thread to run in
if(sthread is null)
sthread = Thread.getNew();
// Schedule the thread to start at the given state and
// label
sthread.scheduleState(this, label.offs);
assert(sthread.isScheduled);
}
}
// If nothing is scheduled, kill the thread
if(sthread !is null && !sthread.isScheduled)
{
assert(sthread.isTransient);
sthread.kill();
// Zero out any pointers to the thread.
if(sthread is cthread)
cthread = null;
sthread = null;
}
assert(sthread is null || sthread.isScheduled);
}
void clearState() { setState(cast(State*)null, null); }
// Index version of setState - called from bytecode
void setState(int st, int label, int clsInd)
{
if(st == -1)
{
assert(label == -1);
clearState();
return;
}
auto cls = cls.upcast(clsInd);
// TODO: This does not support virtual states yet
auto pair = cls.findState(st, label);
assert(pair.state.index == st);
assert(pair.state.owner is cls);
setState(pair.state, pair.label);
}
// Named version of the above function. An empty string sets the
// state to -1 (the empty state.) If no label is given (or given as
// ""), this is equivalent to the script command state=name; If a
// label is given, it is equivalent to state = name.label;
void setState(char[] name, char[] label = "")
{
if(label == "")
{
if(name == "") clearState();
else setState(cls.findState(name), null);
return;
}
assert(name != "", "The empty state cannot contain the label " ~ label);
auto stl = cls.findState(name, label);
setState(stl.state, stl.label);
}
char[] toString()
{
return cls.toString ~ "#" ~ .toString(cast(int)getIndex());
}
}
alias FreeList!(MonsterObject) ObjectList;
// The freelist used for allocation of objects. This contains all
// allocated and in-use objects.
ObjectList allObjects;
// Convert an index to an object pointer
MonsterObject *getMObject(MIndex index)
{
if(index == 0)
fail("Null object reference encountered");
if(index < 0 || index > ObjectList.totLength())
fail("Invalid object reference");
MonsterObject *obj = ObjectList.getNode(index-1);
if(obj.cls is null)
fail("Dead object reference (index " ~ toString(cast(int)index) ~ ")");
assert(obj.getIndex() == index);
return obj;
}

52
old_d_version/monster/vm/params.d
Unescape Escape View File

@ -1,52 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (params.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.params;
import monster.vm.mobject;
import monster.vm.thread;
/* This module offers a "friendly" interface for dealing with
parameters and return values on the stack. It is meant to be an
alternative to manipulating the stack directly when writing native
functions.
NOT FINISHED!
*/
Params params;
struct Params
{
static:
// Get the current object (the 'this' reference for the current
// function)
MonsterObject *obj()
{
assert(cthread !is null);
assert(cthread.fstack.cur !is null);
assert(cthread.fstack.cur.obj !is null);
return cthread.fstack.cur.obj;
}
}

454
old_d_version/monster/vm/stack.d
Unescape Escape View File

@ -1,454 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (stack.d) is part of the Monster script language
package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.stack;
import std.string;
import std.stdio;
import std.utf;
import monster.compiler.scopes;
import monster.compiler.functions;
import monster.options;
import monster.vm.mobject;
import monster.vm.mclass;
import monster.vm.arrays;
import monster.vm.error;
// Stack. There's only one global instance, but threads will make
// copies when they need it.
CodeStack stack;
struct FunctionRef
{
MIndex obj;
int fIndex;
MonsterObject *getObject()
{ return getMObject(obj); }
Function *getFunctionNonVirtual()
{ return functionList[fIndex]; }
Function *getFunction()
{
auto f = getFunctionNonVirtual();
return f.findVirtual(getObject());
}
void set(Function* fn, MonsterObject *mo)
{
assert(fn !is null);
assert(mo !is null);
assert(mo.cls.childOf(fn.owner));
fIndex = fn.getGIndex();
obj = mo.getIndex();
}
}
static assert(FunctionRef.sizeof == 8);
// A simple stack. All data are in chunks of 4 bytes
struct CodeStack
{
private:
int[] data;
int left, total;
int *pos; // Current position
public:
void init()
{
data.length = maxStack;
left = maxStack;
total = maxStack;
pos = data.ptr;
}
// Get the current position index.
int getPos()
{
return total-left;
}
// Reset the stack level to zero.
void reset()
{
left = total;
pos = data.ptr;
}
void pushInt(int i)
{
left--;
if(left<0) overflow("pushInt");
*pos = i;
pos++;
}
void pushLong(long i)
{
left -= 2;
if(left<0) overflow("pushLong");
*(cast(long*)pos) = i;
pos+=2;
}
int popInt()
{
left++;
if(left>total) overflow("popInt");
pos--;
return *pos;
}
long popLong()
{
left+=2;
if(left>total) overflow("popLong");
pos-=2;
return *(cast(long*)pos);
}
// Get the pointer to an int at the given position backwards from
// the current stack pointer. 0 means the first int, ie. the one we
// would get if we called popInt. 1 is the next, etc
int *getInt(int ptr)
{
ptr++;
if(ptr < 1 || ptr > (total-left) )
fail("CodeStack.getInt() pointer out of range");
return pos-ptr;
}
// Get the array _beginning_ at ptr
int[] getInts(int ptr, int len)
{
assert(len > 0 && ptr >= len-1);
if(left+len-ptr>total) overflow("getInts");
return getInt(ptr)[0..len];
}
// Pops the next len ints off the stack and returns them as an
// array. The array is ordered as the values were pushed, not as
// they would have been popped (ie. this function is like popping
// one big value of the stack.) The array is a direct slice of the
// stack, so don't store it or use it after pushing other values.
int[] popInts(int len)
{
assert(len > 0);
int[] r = getInts(len-1, len);
pop(len);
assert(r.length == len);
return r;
}
void pushInts(int[] arr)
{
left -= arr.length;
if(left<0) overflow("pushInts");
pos[0..arr.length] = arr[];
pos+=arr.length;
}
// Pushing and poping objects of the stack - will actually push/pop
// their index.
void pushObject(MonsterObject *mo)
{ pushInt(mo.getIndex); }
MonsterObject *popObject()
{ return getMObject(cast(MIndex)popInt()); }
MonsterObject *peekObject()
{ return getMObject(cast(MIndex)peekInt()); }
// Push arrays of objects. TODO: These do memory allocation, and I'm
// not sure that belongs here. I will look into it later.
void pushObjects(MonsterObject *objs[])
{
int[] indices;
indices.length = objs.length;
foreach(i, mo; objs)
indices[i] = mo.getIndex();
pushIArray(indices);
}
MonsterObject*[] popObjects()
{
MIndex[] indices = cast(MIndex[]) popIArray();
MonsterObject* objs[];
objs.length = indices.length;
foreach(i, ind; indices)
objs[i] = getMObject(ind);
return objs;
}
// Push and pop array references.
void pushArray(ArrayRef *ar)
{ pushInt(ar.getIndex); }
ArrayRef *popArray()
{ return arrays.getRef(cast(AIndex)popInt()); }
ArrayRef *getArray(int i)
{ return arrays.getRef(cast(AIndex)*getInt(i)); }
ArrayRef *peekArray()
{ return getArray(0); }
// More easy versions. Note that pushArray() will create a new array
// reference each time it is called! Only use it if this is what you
// want.
void pushCArray(dchar[] str) { pushArray(arrays.create(str)); }
void pushIArray(int[] str) { pushArray(arrays.create(str)); }
void pushUArray(uint[] str) { pushArray(arrays.create(str)); }
void pushLArray(long[] str){ pushArray(arrays.create(str)); }
void pushULArray(ulong[] str) { pushArray(arrays.create(str)); }
void pushFArray(float[] str) { pushArray(arrays.create(str)); }
void pushDArray(double[] str) { pushArray(arrays.create(str)); }
void pushAArray(AIndex[] str) { pushArray(arrays.create(str)); }
void pushMArray(AIndex[] str) { pushArray(arrays.create(str)); }
alias pushCArray pushArray, pushString;
alias pushIArray pushArray;
alias pushFArray pushArray;
alias pushAArray pushArray;
alias pushString8 pushArray, pushString;
dchar[] popCArray() { return popArray().carr; }
int[] popIArray() { return popArray().iarr; }
float[] popFArray() { return popArray().farr; }
AIndex[] popAArray() { return popArray().aarr; }
alias popCArray popString;
void pushString8(char[] str)
{ pushArray(toUTF32(str)); }
char[] popString8()
{ return toUTF8(popString()); }
char[] peekString8()
{ return toUTF8(peekArray().carr); }
// For multibyte arrays
void pushArray(int[] str, int size)
{ pushArray(arrays.create(str, size)); }
// Various convenient conversion templates. These will be inlined,
// so don't worry :) The *4() functions are for types that are 4
// bytes long.
void push4(T)(T var)
{
static assert(T.sizeof == 4);
pushInt(*(cast(int*)&var));
}
T pop4(T)()
{
static assert(T.sizeof == 4);
int i = popInt();
return *(cast(T*)&i);
}
// Gets a pointer to a given stack value. Counts from the head - 0
// is the first int, 1 is the second, etc. Note that it counts in
// ints (four bytes) no matter what the type T is - this is by
// design.
T* get4(T)(int ptr) { return cast(T*)getInt(ptr); }
// Returns the first value on the stack without poping it
T peek4(T)() { return *(cast(T*)getInt(0)); }
// 64 bit version
void push8(T)(T var)
{
static assert(T.sizeof == 8);
pushLong(*(cast(long*)&var));
}
T pop8(T)()
{
static assert(T.sizeof == 8);
long l = popLong();
return *(cast(T*)&l);
}
// Bools are 1 byte in D
void pushBool(bool b)
{
if(b) pushInt(1);
else pushInt(0);
}
bool popBool() { return popInt() != 0; }
alias get4!(bool) getBool;
// Template conversions
alias push4!(MIndex) pushMIndex;
alias pop4!(MIndex) popMIndex;
alias get4!(MIndex) getMIndex;
alias peek4!(MIndex) peekMIndex;
alias push4!(AIndex) pushAIndex;
alias pop4!(AIndex) popAIndex;
alias get4!(AIndex) getAIndex;
alias peek4!(AIndex) peekAIndex;
alias peek4!(int) peekInt;
alias push4!(uint) pushUint;
alias pop4!(uint) popUint;
alias get4!(uint) getUint;
alias peek4!(uint) peekUint;
alias get4!(long) getLong;
alias peek4!(long) peekLong;
alias push8!(ulong) pushUlong;
alias pop8!(ulong) popUlong;
alias get4!(ulong) getUlong;
alias peek4!(ulong) peekUlong;
alias push4!(float) pushFloat;
alias pop4!(float) popFloat;
alias get4!(float) getFloat;
alias peek4!(float) peekFloat;
alias push8!(double) pushDouble;
alias pop8!(double) popDouble;
alias get4!(double) getDouble;
alias peek4!(double) peekDouble;
alias push4!(dchar) pushChar;
alias pop4!(dchar) popChar;
alias get4!(dchar) getChar;
alias peek4!(dchar) peekDchar;
alias push8!(FunctionRef) pushFuncRef;
alias pop8!(FunctionRef) popFuncRef;
alias get4!(FunctionRef) getFuncRef;
alias peek4!(FunctionRef) peekFuncRef;
void pushFuncRef(Function *fn, MonsterObject *obj)
{
FunctionRef f;
f.set(fn,obj);
pushFuncRef(f);
}
void pushFail(T)(T t)
{
static assert(0, "pushType not yet implemented for " ~ T.stringof);
}
T popFail(T)()
{
static assert(0, "popType not yet implemented for " ~ T.stringof);
}
// Generic push template
template pushType(T)
{
static if(is(T == MIndex) || is(T == AIndex) ||
is(T == int) || is(T == uint) || is(T == float))
alias push4!(T) pushType;
else static if(is(T == long) || is(T == ulong) ||
is(T == double) || is(T == dchar))
alias push8!(T) pushType;
else
alias pushFail!(T) pushType;
}
// Ditto for pop
template popType(T)
{
static if(is(T == MIndex) || is(T == AIndex) ||
is(T == int) || is(T == uint) || is(T == float))
alias pop4!(T) popType;
else static if(is(T == long) || is(T == ulong) ||
is(T == double) || is(T == dchar))
alias pop8!(T) popType;
else
alias popFail!(T) popType;
}
// Pop off and ignore a given amount of values
void pop(int num)
{
left += num;
if(left>total) overflow("pop1");
pos -= num;
}
// Pop off and ignore given values, but remember the top
// values. Equivalent to popping of (and storing) 'keep' ints, then
// poping away 'num' ints, and finally pushing the kept ints
// back. The final stack imprint is -num.
void pop(uint num, uint keep)
{
assert(keep>0);
assert(num>0);
left += num;
// We move the stack pointer back num values, but we access as far
// back as num+keep values, so we need to check that we are still
// within the stack.
if((left+keep)>total) overflow("pop2");
int *from = pos-keep; // Where to get the 'keep' values from
int *to = from-num; // Where they end up
pos -= num; // Where the final stack pointer should be
assert(to < from);
// Copy the values
for(; keep>0; keep--)
*(to++) = *(from++);
}
void debugPrint()
{
writefln("Stack:");
foreach(int i, int val; data[0..total-left])
writefln("%s: %s", i, val);
writefln();
}
private:
void overflow(char[] func)
{
char[] res;
if(left<0)
res = format("Stack overflow by %s ints in CodeStack.%s()",
-left, func);
else if(left>total)
res = format("Stack underflow by %s ints in CodeStack.%s()",
left-total, func);
else res = format("Internal error in CodeStack.%s(), left=%s, total=%s",
func, left, total);
fail(res);
}
}

1792
old_d_version/monster/vm/thread.d
View File

File diff suppressed because it is too large Load Diff

334
old_d_version/monster/vm/vm.d
Unescape Escape View File

@ -1,334 +0,0 @@
/*
Monster - an advanced game scripting language
Copyright (C) 2007-2009 Nicolay Korslund
Email: <korslund@gmail.com>
WWW: http://monster.snaptoad.com/
This file (vm.d) is part of the Monster script language package.
Monster is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
module monster.vm.vm;
import monster.vm.error;
import monster.vm.thread;
import monster.vm.mclass;
import monster.vm.mobject;
import monster.vm.init;
import monster.compiler.tokenizer;
import monster.compiler.linespec;
import monster.compiler.functions;
import monster.compiler.assembler;
import monster.compiler.scopes;
import monster.modules.timer;
import monster.modules.frames;
import monster.modules.vfs;
import monster.options;
import std.stream;
import std.string;
import std.stdio;
import std.utf;
import std.format;
import monster.util.string;
VM vm;
struct VM
{
// Run a script file in the context of the object obj. If no object
// is given, an instance of an empty class is used.
Thread *run(char[] file, MonsterObject *obj = null)
{
init();
Thread *trd;
auto func = new Function;
if(obj !is null)
{
*func = Function(file, obj.cls);
trd = func.call(obj);
}
else
{
*func = Function(file);
trd = func.call();
}
return trd;
}
void frame(float time = 0)
{
static if(!timer_useClock)
{
if(time != 0)
idleTime.add(time);
}
updateFrames(time);
scheduler.doFrame();
}
// Load a class based on class name, file name, or both.
MonsterClass load(char[] nam1, char[] nam2 = "")
{ return doLoad(nam1, nam2, true, true); }
// Case insensitive with regards to the given class name
MonsterClass loadCI(char[] nam1, char[] nam2 = "")
{ return doLoad(nam1, nam2, false, true); }
// Does not fail if the class is not found, just returns null. It
// will still fail if the class exists and contains errors.
MonsterClass loadNoFail(char[] nam1, char[] nam2 = "")
{ return doLoad(nam1, nam2, true, false); }
// Load a class from a stream. The filename parameter is only used
// for error messages.
MonsterClass load(Stream s, char name[] = "", int bom=-1)
{
init();
assert(s !is null, "Cannot load from null stream");
auto mc = new MonsterClass(global);
mc.parse(s, name, bom);
return mc;
}
// Load a class from a token array. The filename parameter is only
// used for error messages.
MonsterClass load(ref TokenArray toks, char[] name = "")
{
init();
auto mc = new MonsterClass(global);
mc.parse(toks, name);
return mc;
}
// Load a class from a string containing the script. The filename
// parameter is only used for error messages.
MonsterClass loadString(char[] str, char[] name="")
{
init();
assert(str != "", "Cannot load empty string");
auto ms = new MemoryStream(str);
if(name == "") name = "(string)";
return load(ms, name);
}
void addPath(char[] path)
{
init();
addVFS(new FileVFS(path));
}
void addVFS(VFS fs) { init(); vfs.add(fs); }
void addVFSFirst(VFS fs) { init(); vfs.addFirst(fs); }
void init()
{
if(!initHasRun)
doMonsterInit();
}
// This is called from init(), you don't have to call it yourself.
void doVMInit()
{
assert(vfs is null);
vfs = new ListVFS;
static if(vmAddCWD) addPath("./");
}
ListVFS vfs;
private:
// Load file based on file name, class name, or both. The order of
// the strings doesn't matter, and name2 can be empty. useCase
// determines if we require a case sensitive match between the given
// class name and the loaded name. If doThrow is true, we throw an
// error if the class was not found, otherwise we just return null.
MonsterClass doLoad(char[] name1, char[] name2, bool useCase, bool doThrow)
{
init();
char[] fname, cname;
MonsterClass mc;
PackageScope pack = global;
assert(pack !is null);
if(name1 == "")
fail("Cannot give empty first parameter to load()");
if(name1.iEnds(".mn"))
{
fname = name1;
cname = name2;
}
else
{
fname = name2;
cname = name1;
}
if(cname.iEnds(".mn"))
fail("load() recieved two filenames: " ~ fname ~ " and " ~ cname);
// The filename must either be empty, or end with .mn
if(fname != "" && !fname.iEnds(".mn"))
fail("Neither " ~ name1 ~ " nor " ~ name2 ~
" is a valid script filename.");
// Remember if cname was originally set
bool cNameSet = (cname != "");
// Was a filename given?
if(fname != "")
{
// Derive the class and package names from the given file name.
VFS.checkForEscape(fname);
char[] file = fname;
while(true)
{
// Find a path separator
int ind = file.find('/');
if(ind == -1)
ind = file.find('\\');
if(ind == -1) break;
// The file is in a directory. Add it as a package.
char[] packname = file[0..ind];
file = file[ind+1..$];
// Empty directory name (eg. dir//file.mn or
// dir/./file.mn) should not be added as packages.
if(packname != "" && packname != ".")
pack = pack.insertPackage(packname);
// Did we end with a path separator?
if(file == "")
fail("File name " ~ fname ~ " is a directory");
}
// 'file' now contains the base filename, without the
// directory
assert(file.iEnds(".mn"));
// Pick away the extension
file = file[0..$-3];
if(!cNameSet)
// No class name given, set it to the derived name
cname = file;
else
{
// Both names were given, make sure they match
if(cname.find('.') != -1)
fail(format("Don't use a package specifier in the class name when the file name is also given (class %s, file %s)",
cname, fname));
if(icmp(file,cname) != 0)
fail(format("Class name %s does not match file name %s",
cname, fname));
}
}
else
{
// Pick out the package part of the class name.
char[] pname = cname;
while(true)
{
int ind = find(pname, '.');
if(ind != -1)
{
// Found a package name separator. Insert the package.
pack = pack.insertPackage(pname[0..ind]);
pname = pname[ind+1..$];
if(pname == "")
fail("Class name cannot end with a period: " ~ cname);
}
else break;
}
cname = pname;
// Derive the file name from the given class name.
fname = pack.getPath(tolower(cname)) ~ ".mn";
}
assert(cname != "" && !cname.iEnds(".mn"));
assert(fname.iEnds(".mn"));
if(!isValidIdent(cname))
fail(format("Invalid class name %s (file %s)", cname, fname));
// At this point, check if the class already exists.
if(pack.ciInList(cname, mc))
{
// Match!
assert(mc !is null);
// If the class name was given, we must have an exact match.
if(cNameSet && (cname != mc.name.str))
fail(format("Searched for %s but could only find case insensitive match %s",
cname, mc.name.str));
// All is good, return the class.
return mc;
}
// No existing class. Search for the script file.
if(!vfs.has(fname))
{
if(doThrow)
fail("Cannot find script file " ~ fname);
else return null;
}
// Create a temporary file stream and load it
auto bf = vfs.open(fname);
auto ef = new EndianStream(bf);
int bom = ef.readBOM();
mc = new MonsterClass(pack);
mc.parse(ef, fname, bom);
delete bf;
// After the class is loaded, we can check its real name.
// If the name matches, we're done.
if(cname == mc.name.str) return mc;
// Allow a case insensitive match if useCase is false or the name
// was not given.
if((!useCase || !cNameSet) && (icmp(cname, mc.name.str) == 0)) return mc;
// Oops, name mismatch
fail(format("%s: Expected class name %s does not match loaded name %s",
fname, cname, mc.name.str));
assert(0);
}
}

62
old_d_version/mscripts/config.mn
Unescape Escape View File

@ -1,62 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (config.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
singleton Config;
// Only some config options have been moved into Monster. Key bindings
// and other low-level settings are still handled in D.
float musicVolume;
float sfxVolume;
float mainVolume;
bool useMusic;
float mouseSensX;
float mouseSensY;
bool flipMouseY;
import sound;
// TODO: This could be replaced by some sort of hook placed on
// mainVolume. Writing to the variable would automatically update
// everything.
setMainVolume(float f)
{
mainVolume = f;
Music.updateVolume();
}
setMusicVolume(float f)
{
musicVolume = f;
Music.updateVolume();
}
setSfxVolume(float f)
{
sfxVolume = f;
// TODO: Update something here
}
// Returns the "real" music volume
float calcMusicVolume() { return mainVolume * musicVolume; }

50
old_d_version/mscripts/console.mn
Unescape Escape View File

@ -1,50 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (console.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Console
// This class contains all the functions available to the ingame
// console.
import game
// Change player physics mode
native walk();
native fly();
native ghost();
// Clear the console
native clear();
// Set the console log font
native setfont(char[] name);
// Exit the game
native exit();
quit() { exit(); }
// Toggle wireframe mode
native wireframe();
twf() { wireframe() }

35
old_d_version/mscripts/fpsticker.mn
Unescape Escape View File

@ -1,35 +0,0 @@
// Small script that prints the FPS to screen with regular intervals.
import frames;
// Set up the text widget
Widget txt = gui.text("StaticText",
gui.getWidth()-90, 10, 120, 30,
"Statistic");
txt.setNeedMouseFocus(false);
txt.setTextColor(1,1,1);
txt.setCaption("hello!");
// Sleep until rendering begins. This just prevents the first printed
// value from being 'nan'
fsleep(0);
// counter and totalTime (in the 'frames' module) are updated
// automatically by the system.
ulong lastFrame = counter;
float lastTime = totalTime;
float delay = 1.5;
while(true)
{
sleep(delay);
// Calculate differences since last frame
ulong fdiff = counter-lastFrame;
float tdiff = totalTime-lastTime;
txt.setCaption("fps: ", fdiff/tdiff);
lastFrame = counter;
lastTime = totalTime;
}

25
old_d_version/mscripts/game/activator.mn
Unescape Escape View File

@ -1,25 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (activator.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Activator : GameObject;

40
old_d_version/mscripts/game/actor.mn
Unescape Escape View File

@ -1,40 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (actor.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Actors are a common base class for creatures, NPCs and the player.
class Actor : GameObject;
// The actor's level
int level;
// Stats. These are the base values, before any positive or negative
// effects are applied.
int
baseStrength, baseIntelligence, baseWillpower, baseAgility,
baseSpeed, baseEndurance, basePersonality, baseLuck;
// Maximum health values, before any effects are applied.
int baseMaxHealth, baseMaxMana, baseMaxFatigue;
// Amount of gold this actor is carrying
int gold;

35
old_d_version/mscripts/game/apparatus.mn
Unescape Escape View File

@ -1,35 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (apparatus.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Covers all alchemy apparatus - mortars, retorts, etc
class Apparatus : InventoryItem;
enum AppaType : char[] altName
{
MortarPestle = 0 : "Mortar and Pestle",
Albemic = 1 : "Albemic"
Calcinator = 2 : "Calcinator"
}
float quality;
int type;

28
old_d_version/mscripts/game/armor.mn
Unescape Escape View File

@ -1,28 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (armor.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Covers all weapons and projectile weapons you can carry (like
// arrows and throwable items.)
class Armor : Repairable;
int type, armor;

28
old_d_version/mscripts/game/book.mn
Unescape Escape View File

@ -1,28 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (book.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Book : EnchantItem;
bool isScroll;
int skillID; // Skill that is enhanced by reading this book, if any

41
old_d_version/mscripts/game/clothing.mn
Unescape Escape View File

@ -1,41 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (clothing.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// All items that can be repaired (weapons and armor)
class Clothing : EnchantItem;
int type;
enum Type
{
Pants = 0,
Shoes = 1,
Shirt = 2,
Belt = 3,
Robe = 4,
RGlove = 5,
LGlove = 6,
Skirt = 7,
Ring = 8,
Amulet = 9
}

26
old_d_version/mscripts/game/container.mn
Unescape Escape View File

@ -1,26 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (container.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Container : LockedObject;
float weight; // Not sure, might be max total weight allowed?

36
old_d_version/mscripts/game/creature.mn
Unescape Escape View File

@ -1,36 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (creature.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Creature : Actor;
// Soul gem value
int soul;
// Not sure how to use these
int combat, magic, stealth;
// Attack values for various types of attack
int
attackMin1, attackMax1,
attackMin2, attackMax2,
attackMin3, attackMax3;

32
old_d_version/mscripts/game/door.mn
Unescape Escape View File

@ -1,32 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (door.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Door : LockedObject;
// Does this door transport you to another cell?
bool teleport;
// Door destination
float destx, desty, destz;
float destr1, destr2, destr3;
char[] destCell;

27
old_d_version/mscripts/game/enchantitem.mn
Unescape Escape View File

@ -1,27 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (enchantitem.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Items that can be enchanted
class EnchantItem : InventoryItem;
int enchant;

79
old_d_version/mscripts/game/gameobject.mn
Unescape Escape View File

@ -1,79 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (gameobject.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// An object that exists inside a cell. All cell objects must have a
// position in space.
class GameObject;
// Is this object placed in a cell? isPlaced is true if the object is
// displayed inside a cell with a mesh and given 3D coordinates, and
// false otherwise (eg. if it is part of the player's inventory or in
// a container.)
// TODO: This will change to an actual cell reference later on, and be
// null if the object is not placed.
bool isPlaced;
// Position and rotation in space (only valid if isPlaced is true.)
float x, y, z;
float r1, r2, r3;
float scale = 1.0;
char[] name, id;
// Various variables that are currently unused. Most of the strings
// will be replaced by object references at some point.
// Owner of an object / activator
char[] owner;
// A global variable? Don't know what it's used for.
char[] glob;
// Reference to a soul trapped creature?
char[] soulID;
// Faction owner? Rank?
char[] cnam;
int indx;
// Magic value / health / uses of an item?
float xchg;
// These depend on the item in question
int intv, nam9;
int fltv;
int unam;
// TODO: Scripts
// Cute hack for the console
char[] pos()
{
// TODO: Make this simpler
char[] xx = x;
char[] yy = y;
char[] zz = z;
return "X:" ~ xx ~ " Y:" ~ yy ~ " Z:" ~ zz;
}

27
old_d_version/mscripts/game/ingredient.mn
Unescape Escape View File

@ -1,27 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (ingredient.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Alchemy ingredients
class Ingredient : InventoryItem;
// more to come here...

31
old_d_version/mscripts/game/inventoryitem.mn
Unescape Escape View File

@ -1,31 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (inventoryitem.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class InventoryItem : GameObject;
float weight;
int value;
// Reference to current container. Player / NPC inventories are also
// containers. Not used yet.
Container holder;

31
old_d_version/mscripts/game/light.mn
Unescape Escape View File

@ -1,31 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (light.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Light : InventoryItem;
// Time left in seconds (for carried lights)
float lifetime;
int radius;
uint flags;

30
old_d_version/mscripts/game/lockedobject.mn
Unescape Escape View File

@ -1,30 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (lockedobject.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Objects that can have a lock level and a trap
class LockedObject : GameObject;
// ID of key and trap type.
char[] key, trap;
int lockLevel;

24
old_d_version/mscripts/game/lockpick.mn
Unescape Escape View File

@ -1,24 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (lockpick.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Lockpick : Tool;

30
old_d_version/mscripts/game/misc.mn
Unescape Escape View File

@ -1,30 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (misc.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Misc inventory items, like bottles, pots, pillows, keys etc. They
// are mostly useless (except keys), but may be bought and sold.
class Misc : InventoryItem;
// Not quite sure what the significance of this is. It is set to
// non-zero for some keys, but not for all.
int isKey;

25
old_d_version/mscripts/game/npc.mn
Unescape Escape View File

@ -1,25 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (npc.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class NPC : Person

26
old_d_version/mscripts/game/person.mn
Unescape Escape View File

@ -1,26 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (person.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Person : Actor;
int disposition, reputation, rank;

27
old_d_version/mscripts/game/player.mn
Unescape Escape View File

@ -1,27 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (player.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
singleton player : Person
name="Player Name"
level = 5 // Just an example value

26
old_d_version/mscripts/game/potion.mn
Unescape Escape View File

@ -1,26 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (potion.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
class Potion : InventoryItem;
int autoCalc;

25
old_d_version/mscripts/game/probe.mn
Unescape Escape View File

@ -1,25 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (probe.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Probes - tools used for disarming traps
class Probe : Tool;

27
old_d_version/mscripts/game/repairable.mn
Unescape Escape View File

@ -1,27 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (repairable.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// All items that can be repaired (weapons and armor)
class Repairable : EnchantItem;
int health;

25
old_d_version/mscripts/game/repairitem.mn
Unescape Escape View File

@ -1,25 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (repairitem.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Hammers etc. used to repair weapons and armor
class RepairItem : Tool;

25
old_d_version/mscripts/game/static.mn
Unescape Escape View File

@ -1,25 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (static.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Static meshes - walls, buildings, rocks, etc.
class Static : GameObject;

28
old_d_version/mscripts/game/tool.mn
Unescape Escape View File

@ -1,28 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (tool.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Common base class for probes, lock picks and repair hammers.
class Tool : InventoryItem;
float quality;
int uses;

31
old_d_version/mscripts/game/weapon.mn
Unescape Escape View File

@ -1,31 +0,0 @@
/*
OpenMW - The completely unofficial reimplementation of Morrowind
Copyright (C) 2008 Nicolay Korslund
Email: < korslund@gmail.com >
WWW: http://openmw.snaptoad.com/
This file (weapon.mn) is part of the OpenMW package.
OpenMW is distributed as free software: you can redistribute it
and/or modify it under the terms of the GNU General Public License
version 3, as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
version 3 along with this program. If not, see
http://www.gnu.org/licenses/ .
*/
// Covers all weapons and carry-able projectiles.
class Weapon : Repairable;
float speed, reach;
// Not set yet.
bool magical, silver;
bool twoHanded;

2088
old_d_version/mscripts/gmst.mn
View File

File diff suppressed because it is too large Load Diff

5
old_d_version/mscripts/guiscripts/makegui.mn
Unescape Escape View File

@ -1,5 +0,0 @@
/*
Widget hud;
hud = gui.loadLayout("openmw_hud_layout.xml");
hud.setCoord(10,10,500,500);
*/

11
old_d_version/mscripts/guiscripts/module/gui.mn
Unescape Escape View File

@ -1,11 +0,0 @@
// GUI module. Only covers some very basic functions.
module gui;
// Later, we'll have singleton gui : Widget; with most of the
// functions defined in Widget.
native Widget loadLayout(char[] file);
native Widget text(char[] skin, int x, int y, int w, int h,
char[] layer);
native int getWidth();
native int getHeight();

10
old_d_version/mscripts/guiscripts/module/widget.mn
Unescape Escape View File

@ -1,10 +0,0 @@
class Widget;
native setNeedMouseFocus(bool b);
native setTextColor(float r, float g, float b);
native setCoord(int x, int y, int w, int h);
native setCaption(char[][] str...);
// Find a named child widget
native Widget get(char[] name);

Some files were not shown because too many files have changed in this diff Show More

Write Preview
Loading…
Cancel
Save