ref: 2c25717e993049085ce20d1793e5474f6594c4f3
dir: /Game/src/scriplib.c/
//-------------------------------------------------------------------------
/*
Copyright (C) 1996, 2003 - 3D Realms Entertainment
This file is part of Duke Nukem 3D version 1.5 - Atomic Edition
Duke Nukem 3D is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
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
aint32_t with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Original Source: 1996 - Todd Replogle
Prepared for public release: 03/21/2003 - Charlie Wiederhold, 3D Realms
*/
//-------------------------------------------------------------------------
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "duke3d.h"
#include "scriplib.h"
/* #define DEBUG_SCRIPLIB */
#define MAX_SCRIPTS 5
typedef enum {
SCRIPTFLAG_UNKNOWN,
SCRIPTFLAG_CATEGORY,
SCRIPTFLAG_ONESTRING,
SCRIPTFLAG_TWOSTRING,
SCRIPTFLAG_HEX,
SCRIPTFLAG_DECIMAL,
SCRIPTFLAG_FLOAT
} scriptflag_t;
typedef struct scriptnode_s {
struct scriptnode_s *child;
struct scriptnode_s *sibling;
char *key;
scriptflag_t type;
union {
char *string[2];
int number;
float floatnumber;
} data;
} scriptnode_t;
static int script_nexthandle = 0;
static int script_numscriptsopen = 0;
static scriptnode_t *script_headnode[MAX_SCRIPTS];
/* Utility functions */
static scriptnode_t *SCRIPT_constructnode (void)
{
scriptnode_t *s;
s = (scriptnode_t *) malloc (sizeof (scriptnode_t));
if (s != NULL)
{
s->child = NULL;
s->sibling = NULL;
s->key = NULL;
s->data.string[0] = NULL;
s->data.string[1] = NULL;
s->type = SCRIPTFLAG_UNKNOWN;
}
return s;
}
static void SCRIPT_freenode (scriptnode_t *node)
{
assert (node != NULL);
if (node->type == SCRIPTFLAG_ONESTRING) {
free (node->data.string[0]);
} else if (node->type == SCRIPTFLAG_TWOSTRING) {
free (node->data.string[0]);
free (node->data.string[1]);
}
free (node->key);
free (node->sibling);
free (node->child);
free (node);
}
static void SCRIPT_writenode (scriptnode_t *node, FILE *fp)
{
switch (node->type)
{
case SCRIPTFLAG_UNKNOWN:
return;
break;
case SCRIPTFLAG_CATEGORY:
fprintf (fp, "\n[%s]\n", node->key);
break;
case SCRIPTFLAG_ONESTRING:
fprintf (fp, "%s = \"%s\"\n", node->key, node->data.string[0]);
break;
case SCRIPTFLAG_TWOSTRING:
fprintf (fp, "%s = \"%s\" \"%s\"\n", node->key, node->data.string[0], node->data.string[1]);
break;
case SCRIPTFLAG_HEX:
fprintf (fp, "%s = 0x%X\n", node->key, node->data.number);
break;
case SCRIPTFLAG_DECIMAL:
fprintf (fp, "%s = %d\n", node->key, node->data.number);
break;
case SCRIPTFLAG_FLOAT:
fprintf (fp, "%s = %ff\n", node->key, node->data.floatnumber);
break;
}
}
static void SCRIPT_recursivewrite (scriptnode_t *node, FILE *fp)
{
if (node == NULL) return;
SCRIPT_writenode (node, fp);
/* Free dependant nodes first */
if (node->child) {
SCRIPT_recursivewrite (node->child, fp);
}
if (node->sibling) {
SCRIPT_recursivewrite (node->sibling, fp);
}
}
static void SCRIPT_recursivefree (scriptnode_t *node)
{
assert (node != NULL);
/* Free dependant nodes first */
if (node->child) {
SCRIPT_recursivefree (node->child);
node->child = NULL;
}
if (node->sibling) {
SCRIPT_recursivefree (node->sibling);
node->sibling = NULL;
}
SCRIPT_freenode (node);
node = NULL;
}
static void SCRIPT_addsibling (scriptnode_t *node, scriptnode_t *sibling)
{
assert (node != NULL);
assert (sibling != NULL);
/* printf ("addsib: %p, %p, %p\n", node, node->sibling, sibling); */
if (node->sibling == NULL) {
node->sibling = sibling;
} else {
SCRIPT_addsibling (node->sibling, sibling);
}
}
static void SCRIPT_addchild (scriptnode_t *parent, scriptnode_t *child)
{
assert (parent != NULL);
assert (child != NULL);
if (parent->child == NULL) {
parent->child = child;
} else {
SCRIPT_addsibling (parent->child, child);
}
}
static char *SCRIPT_copystring (char * s)
{
char *ret;
ret = (char *) malloc (strlen (s)+1);
if (ret != NULL)
{
strcpy (ret, s);
}
return ret;
}
static int SCRIPT_getnexttoken (char *buffer, char * token, int start)
{
int iterator = start;
if (buffer[start] == '\0') {
token[0] = '\0';
return start;
}
while (iterator < 128 && !isspace (buffer[iterator]))
{
token[iterator-start] = buffer[iterator];
iterator++;
}
token[iterator-start] = '\0';
/* Trim off any extra whitespace */
while (iterator < 127 && isspace(buffer[iterator+1]))
iterator++;
return ++iterator;
}
/* Fills in a scriptnode with the interpreted contents of a line */
static void SCRIPT_parseline (char *curline, scriptnode_t *node)
{
char token[128];
int i;
/* Needs to handle 5 cases: */
/* key = someint */
/* key = 0xsomehexnum */
/* key = ~ */
/* key = "onestring" */
/* key = "two" "strings" */
assert (node != NULL);
assert (curline != NULL);
i = SCRIPT_getnexttoken (curline, token, 0);
node->key = SCRIPT_copystring (token);
i = SCRIPT_getnexttoken (curline, token, i);
/* Sanity check... this token should be "=" */
if (strcmp (token, "=")) {
/* Error state, free the memory allocated */
SCRIPT_recursivefree (node);
return;
}
/* This is where the real fun begins... */
/* we can begin to determine which of the 6 */
/* possibilities the node is now */
i = SCRIPT_getnexttoken (curline, token, i);
if (!strncmp (token, "0x", 2)) {
/* Found a hex digit! */
node->type = SCRIPTFLAG_HEX;
node->data.number = strtol (token, NULL, 16);
}else if (token[strlen(token) - 1] == 'f') {
/* Found a float */
node->type = SCRIPTFLAG_FLOAT;
node->data.floatnumber = atof(token);
}else if (isdigit (token[0])) {
/* Found a number! */
node->type = SCRIPTFLAG_DECIMAL;
node->data.number = atoi (token);
}else if (token[0] == '-' && isdigit (token[1])) {
/* Found a negative number! */
node->type = SCRIPTFLAG_DECIMAL;
node->data.number = atoi (token);
//- FIX_00067: *.cfg parser fails to read negative values (as it could be for the Midi selection)
// was node->data.number = 0; Can't find a reason for this.
}else if (token[0] == '~') {
/* Found a ... who knows */
node->type = SCRIPTFLAG_DECIMAL;
node->data.number = -1;
}else if (token[0] == '"') {
char workbuf[128];
int r;
/* Found one of possibly two strings */
strcpy (workbuf, token);
while (token != NULL && workbuf[strlen(workbuf)-1] != '"')
{
i = SCRIPT_getnexttoken (curline, token, i);
strcat (workbuf, " ");
strcat (workbuf, token);
}
r = sscanf(workbuf, "\"%[^\"]\"", workbuf);
if (r == 0) workbuf[0] = '\0';
node->type = SCRIPTFLAG_ONESTRING;
node->data.string[0] = SCRIPT_copystring (workbuf);
/* Check for a second string */
i = SCRIPT_getnexttoken (curline, token, i);
if (token[0] == '"') {
strcpy (workbuf, token);
while (token != NULL && workbuf[strlen(workbuf)-1] != '"')
{
i = SCRIPT_getnexttoken (curline, token, i);
strcat (workbuf, " ");
strcat (workbuf, token);
}
r = sscanf(workbuf, "\"%[^\"]\"", workbuf);
if (r == 0) workbuf[0] = '\0';
node->type = SCRIPTFLAG_TWOSTRING;
node->data.string[1] = SCRIPT_copystring (workbuf);
}
} else {
/* Error state! */
SCRIPT_recursivefree (node);
}
}
static scriptnode_t *SCRIPT_findinchildren (scriptnode_t *parent, char *s)
{
scriptnode_t *cur = parent;
if (cur == NULL) return NULL;
cur = cur->child;
if (cur == NULL) return NULL;
while (cur != NULL)
{
if (!strcmp(cur->key, s))
break;
cur = cur->sibling;
}
return cur;
}
/*
==============
=
= SCRIPT_Init
=
==============
*/
int32 SCRIPT_Init( uint8_t * name )
{
STUBBED("Init");
return -1;
}
/*
==============
=
= SCRIPT_Free
=
==============
*/
void SCRIPT_Free( int32 scripthandle )
{
/* STUBBED("Free"); */
if (scripthandle == -1) return;
SCRIPT_recursivefree (script_headnode[scripthandle]);
script_numscriptsopen--;
}
/*
==============
=
= SCRIPT_Parse
=
==============
*/
int32 SCRIPT_Parse ( uint8_t *data, int32 length, char * name )
{
STUBBED("Parse");
return -1;
}
/*
==============
=
= SCRIPT_Load
=
==============
*/
int32 SCRIPT_Load ( char * filename )
{
FILE *fp;
char curline[128];
scriptnode_t *headnode = NULL;
scriptnode_t *cur_subsection = NULL;
if (script_numscriptsopen == MAX_SCRIPTS) return -1;
/* The main program does not check for any sort of */
/* error in loading, so each SCRIPT_ function needs */
/* to check if the handle is -1 before doing anything */
fp = fopen (filename, "r");
if (fp == NULL) return -1;
/* Start loading the script */
/* Loads and parse the entire file into a tree */
script_numscriptsopen++;
/* script_nexthandle is the current handle until we increment it */
script_headnode[script_nexthandle] = SCRIPT_constructnode ();
headnode = script_headnode[script_nexthandle];
memset (curline, 0, 128);
while (fgets (curline, 128, fp))
{
/* Skip comments */
if (curline[0] == ';') continue;
/* Parse line */
/* We have two options... it starts with a [, making it */
/* a new subsection (child of headnode) or it starts with */
/* a letter, making it a child of a subsection. */
if (curline[0] == '[')
{
scriptnode_t *node;
int i;
/* Remove [] manually */
for (i = 0; i < 127; i++)
curline[i] = curline[i+1];
for (i = 127; i >= 0; i--)
{
if (curline[i] == ']') {
curline[i] = '\0';
break;
} else {
curline[i] = '\0';
}
}
/* Insert into head */
node = SCRIPT_constructnode ();
node->type = SCRIPTFLAG_CATEGORY;
node->key = SCRIPT_copystring (curline);
SCRIPT_addchild (headnode, node);
cur_subsection = node;
/* printf ("Working in section \"%s\"\n", node->key); */
} else if (isalpha (curline[0])) {
scriptnode_t *node;
/* Ignore if not under a subsection */
if (cur_subsection == NULL)
continue;
node = SCRIPT_constructnode ();
/* TODO: Parse line here */
SCRIPT_parseline (curline, node);
if (node != NULL)
{
/* printf ("Adding node with key \"%s\"\n", node->key); */
SCRIPT_addchild (cur_subsection, node);
}
}
memset (curline, 0, 128);
}
fclose (fp);
return script_nexthandle++; /* postincrement is important here */
}
/*
==============
=
= SCRIPT_Save
=
==============
*/
void SCRIPT_Save (int32 scripthandle, char* filename)
{
FILE *fp;
scriptnode_t *head;
if(scripthandle >= MAX_SCRIPTS || scripthandle < 0)
return;
fp = fopen (filename, "w");
if (fp == NULL) return;
head = script_headnode[scripthandle];
SCRIPT_recursivewrite (head, fp);
fclose (fp);
}
/*
==============
=
= SCRIPT_NumberSections
=
==============
*/
int32 SCRIPT_NumberSections( int32 scripthandle )
{
STUBBED("NumberSections");
return -1;
}
/*
==============
=
= SCRIPT_Section
=
==============
*/
uint8_t * SCRIPT_Section( int32 scripthandle, int32 which )
{
STUBBED("Section");
return NULL;
}
/*
==============
=
= SCRIPT_NumberEntries
=
==============
*/
int32 SCRIPT_NumberEntries( int32 scripthandle, char * sectionname )
{
scriptnode_t *node = NULL;
int32 entries = 0;
if(scripthandle >= MAX_SCRIPTS || scripthandle < 0)
return 0;
node = script_headnode[scripthandle];
node = SCRIPT_findinchildren(node, sectionname);
if(!node) return 0;
for(node=node->child; node ; node=node->sibling)
{
++entries;
}
return entries;
}
/*
==============
=
= SCRIPT_Entry
=
==============
*/
char * SCRIPT_Entry( int32 scripthandle, char * sectionname, int32 which )
{
scriptnode_t *node = NULL;
int32 entrynum = 0;
char * val = NULL;
if(scripthandle >= MAX_SCRIPTS || scripthandle < 0)
return "";
node = script_headnode[scripthandle];
node = SCRIPT_findinchildren(node,sectionname);
if(!node) return "";
for(node=node->child; node ; node=node->sibling, ++entrynum)
{
if(entrynum == which)
{
val = node->key;
break;
}
}
return val;
}
/*
==============
=
= SCRIPT_GetRaw
=
==============
*/
char * SCRIPT_GetRaw(int32 scripthandle, char * sectionname, char * entryname)
{
STUBBED("GetRaw");
return NULL;
}
/*
==============
=
= SCRIPT_GetString
=
==============
*/
void SCRIPT_GetString
(
int32 scripthandle,
char * sectionname,
char * entryname,
char * dest
)
{
scriptnode_t *cur;
/* STUBBED("GetString"); */
if (scripthandle == -1) return;
cur = script_headnode[scripthandle];
cur = SCRIPT_findinchildren (cur, sectionname);
cur = SCRIPT_findinchildren (cur, entryname);
if (cur != NULL && cur->type == SCRIPTFLAG_ONESTRING)
{
strcpy (dest, cur->data.string[0]);
#ifdef DEBUG_SCRIPLIB
printf ("GetString: value for %s:%s is %s\n", sectionname, entryname, dest);
#endif
}
}
/*
==============
=
= SCRIPT_GetDoubleString
=
==============
*/
void SCRIPT_GetDoubleString
(
int32 scripthandle,
char * sectionname,
char * entryname,
char * dest1,
char * dest2
)
{
scriptnode_t *cur;
/* STUBBED("GetDoubleString"); */
if (scripthandle == -1) return;
cur = script_headnode[scripthandle];
cur = SCRIPT_findinchildren (cur, sectionname);
cur = SCRIPT_findinchildren (cur, entryname);
if (cur != NULL && cur->type == SCRIPTFLAG_TWOSTRING)
{
strcpy (dest1, cur->data.string[0]);
strcpy (dest2, cur->data.string[1]);
#ifdef DEBUG_SCRIPLIB
printf ("GetDoubleString: value for %s:%s is %s %s\n", sectionname, entryname, dest1, dest2);
#endif
}
}
/*
==============
=
= SCRIPT_GetNumber
=
==============
*/
boolean SCRIPT_GetNumber
(
int32 scripthandle,
char * sectionname,
char * entryname,
int32 * number
)
{
scriptnode_t *cur;
/* STUBBED("GetNumber"); */
if (scripthandle == -1) return false;
cur = script_headnode[scripthandle];
cur = SCRIPT_findinchildren (cur, sectionname);
cur = SCRIPT_findinchildren (cur, entryname);
if (cur != NULL && cur->type == SCRIPTFLAG_DECIMAL)
{
*number = cur->data.number;
#ifdef DEBUG_SCRIPLIB
printf ("GetNumber: value for %s:%s is %ld\n", sectionname, entryname, *number);
#endif
}
return (cur != NULL) ? true : false;
}
/*
==============
=
= SCRIPT_GetBoolean
=
==============
*/
void SCRIPT_GetBoolean
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
boolean * bool
)
{
STUBBED("GetBoolean");
}
/*
==============
=
= SCRIPT_GetFloat
=
==============
*/
boolean SCRIPT_GetFloat
(
int32 scripthandle,
char * sectionname,
char * entryname,
float * floatnumber
)
{
scriptnode_t *cur;
if (scripthandle == -1) return false;
cur = script_headnode[scripthandle];
cur = SCRIPT_findinchildren (cur, sectionname);
cur = SCRIPT_findinchildren (cur, entryname);
if (cur != NULL && cur->type == SCRIPTFLAG_FLOAT)
{
*floatnumber = cur->data.floatnumber;
#ifdef DEBUG_SCRIPLIB
printf ("GetFloat: value for %s:%s is %f\n", sectionname, entryname, *number);
#endif
}
return (cur != NULL) ? true : false;
}
/*
==============
=
= SCRIPT_GetDouble
=
==============
*/
void SCRIPT_GetDouble
(
int32 scripthandle,
char * sectionname,
char * entryname,
double * number
)
{
STUBBED("GetDouble");
}
/*
==============
=
= SCRIPT_PutComment
=
==============
*/
void SCRIPT_PutComment( int32 scripthandle, uint8_t * sectionname, uint8_t * comment )
{
STUBBED("PutComment");
}
/*
==============
=
= SCRIPT_PutEOL
=
==============
*/
void SCRIPT_PutEOL( int32 scripthandle, uint8_t * sectionname )
{
STUBBED("PutEOL");
}
/*
==============
=
= SCRIPT_PutMultiComment
=
==============
*/
void SCRIPT_PutMultiComment
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * comment,
...
)
{
STUBBED("PutMultiComment");
}
/*
==============
=
= SCRIPT_PutSection
=
==============
*/
void SCRIPT_PutSection( int32 scripthandle, uint8_t * sectionname )
{
STUBBED("PutSection");
}
/*
==============
=
= SCRIPT_PutRaw
=
==============
*/
void SCRIPT_PutRaw
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
uint8_t * raw
)
{
STUBBED("PutRaw");
}
/*
==============
=
= SCRIPT_PutString
=
==============
*/
void SCRIPT_PutString
(
int32 scripthandle,
char * sectionname,
char * entryname,
char * string
)
{
scriptnode_t *head;
scriptnode_t *section;
scriptnode_t *node;
if(scripthandle >= MAX_SCRIPTS || scripthandle < 0)
return;
head = script_headnode[scripthandle];
/* We're screwed if there's no head */
if (head == NULL) return;
section = SCRIPT_findinchildren (head, sectionname);
if (section == NULL)
{
/* Add the section if it does not exist */
section = SCRIPT_constructnode ();
section->type = SCRIPTFLAG_CATEGORY;
section->key = SCRIPT_copystring (sectionname);
SCRIPT_addchild (head, section);
}
node = SCRIPT_findinchildren (section, entryname);
if (node == NULL)
{
/* Add the section if it does not exist */
node = SCRIPT_constructnode ();
node->type = SCRIPTFLAG_ONESTRING;
node->key = SCRIPT_copystring (entryname);
SCRIPT_addchild (section, node);
} else {
free (node->data.string[0]);
}
node->data.string[0] = SCRIPT_copystring (string);
}
/*
==============
=
= SCRIPT_PutDoubleString
=
==============
*/
void SCRIPT_PutDoubleString
(
int32 scripthandle,
char * sectionname,
char * entryname,
char * string1,
char * string2
)
{
scriptnode_t *head;
scriptnode_t *section;
scriptnode_t *node;
if(scripthandle >= MAX_SCRIPTS || scripthandle < 0)
return;
head = script_headnode[scripthandle];
/* We're screwed if there's no head */
if (head == NULL) return;
section = SCRIPT_findinchildren (head, sectionname);
if (section == NULL)
{
/* Add the section if it does not exist */
section = SCRIPT_constructnode ();
section->type = SCRIPTFLAG_CATEGORY;
section->key = SCRIPT_copystring (sectionname);
SCRIPT_addchild (head, section);
}
node = SCRIPT_findinchildren (section, entryname);
if (node == NULL)
{
/* Add the section if it does not exist */
node = SCRIPT_constructnode ();
node->type = SCRIPTFLAG_TWOSTRING;
node->key = SCRIPT_copystring (entryname);
SCRIPT_addchild (section, node);
} else {
free (node->data.string[0]);
free (node->data.string[1]);
}
node->data.string[0] = SCRIPT_copystring (string1);
node->data.string[1] = SCRIPT_copystring (string2);
}
/*
==============
=
= SCRIPT_PutNumber
=
==============
*/
void SCRIPT_PutNumber
(
int32 scripthandle,
char * sectionname,
char * entryname,
int32 number,
boolean hexadecimal,
boolean defaultvalue
)
{
/* DDOI - I don't know what "defaultvalue" is for so it's ignored */
scriptnode_t *head;
scriptnode_t *section;
scriptnode_t *node;
if(scripthandle >= MAX_SCRIPTS || scripthandle < 0)
return;
head = script_headnode[scripthandle];
/* We're screwed if there's no head */
if (head == NULL) return;
section = SCRIPT_findinchildren (head, sectionname);
if (section == NULL)
{
/* Add the section if it does not exist */
section = SCRIPT_constructnode ();
section->type = SCRIPTFLAG_CATEGORY;
section->key = SCRIPT_copystring (sectionname);
SCRIPT_addchild (head, section);
}
node = SCRIPT_findinchildren (section, entryname);
if (node == NULL)
{
/* Add the section if it does not exist */
node = SCRIPT_constructnode ();
node->key = SCRIPT_copystring (entryname);
SCRIPT_addchild (section, node);
}
if (hexadecimal)
node->type = SCRIPTFLAG_HEX;
else
node->type = SCRIPTFLAG_DECIMAL;
node->data.number = number;
}
/*
==============
=
= SCRIPT_PutBoolean
=
==============
*/
void SCRIPT_PutBoolean
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
boolean bool
)
{
STUBBED("PutBoolean");
}
/*
==============
=
= SCRIPT_PutDouble
=
==============
*/
void SCRIPT_PutDouble
(
int32 scripthandle,
uint8_t * sectionname,
uint8_t * entryname,
double number,
boolean defaultvalue
)
{
STUBBED("PutDouble");
}