nzp-team/fteqw
0
0
Fork 0
mirror of https://github.com/nzp-team/fteqw.git synced 2024-11-13 07:47:45 +00:00
Code Issues Projects Releases Packages Wiki Activity
fteqw/engine/qclib/qcc_cmdlib.c
Spoike d1d0d86fea Rewrote infostrings. Now using infobuffers, which allows for the use of arbitrary blobs, except not using the protocol extension yet in case it needs to be fixed. 
Fix sound source issues in Q3.
Fix q2 air acceleration/prediction omission.
Don't change console completion while typing (while that option is still possible).
Shift+tab now cycles completion backwards (now ctrl+shift for cycle subconsoles).
Allow a few things to ignore sv_pure - including csprogs files (which is useful for all the mods that come with the csprogs.dat distributed separately).
clamp pitch values to the range documented by openal, to hopefully avoid error spam.
add some colour coding to the text editor when shader files are being edited/viewed.
Changed how overbrights are clamped on q3bsp.
Added portalfboscale for explicit texture scales on portal/refract/reflect fbos.
qc decompiler can now at least attempt to decompile qtest's qc.
fteqccgui can now be pointed at a .pak file, and decompile the progs.dat inside.

git-svn-id: https://svn.code.sf.net/p/fteqw/code/trunk@5269 fc73d0e0-1445-4013-8a0c-d673dee63da5
2018-07-05 16:21:44 +00:00

1347 lines
26 KiB
C
Raw Blame History

// cmdlib.c
#include "qcc.h"
#include <ctype.h>
//#include <sys/time.h>
#undef progfuncs
#define PATHSEPERATOR '/'
#ifndef QCC
extern jmp_buf qcccompileerror;
#endif
// set these before calling CheckParm
int myargc;
char **myargv;
char qcc_token[1024];
int qcc_eof;
const unsigned int type_size[12] = {1, //void
sizeof(string_t)/4, //string
1, //float
3, //vector
1, //entity
1, //field
sizeof(func_t)/4,//function
1, //pointer (its an int index)
1, //integer
3, //fixme: how big should a variant be?
0, //ev_struct. variable sized.
0 //ev_union. variable sized.
};
char *basictypenames[] = {
"void",
"string",
"float",
"vector",
"entity",
"field",
"function",
"pointer",
"integer",
"variant",
"struct",
"union",
"accessor"
};
/*
============================================================================
BYTE ORDER FUNCTIONS
============================================================================
*/
short (*PRBigShort) (short l);
short (*PRLittleShort) (short l);
int (*PRBigLong) (int l);
int (*PRLittleLong) (int l);
float (*PRBigFloat) (float l);
float (*PRLittleFloat) (float l);
short QCC_SwapShort (short l)
{
qbyte b1,b2;
b1 = l&255;
b2 = (l>>8)&255;
return (b1<<8) + b2;
}
short QCC_Short (short l)
{
return l;
}
int QCC_SwapLong (int l)
{
qbyte b1,b2,b3,b4;
b1 = (qbyte)l;
b2 = (qbyte)(l>>8);
b3 = (qbyte)(l>>16);
b4 = (qbyte)(l>>24);
return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
}
int QCC_Long (int l)
{
return l;
}
float QCC_SwapFloat (float l)
{
union {qbyte b[4]; float f;} in, out;
in.f = l;
out.b[0] = in.b[3];
out.b[1] = in.b[2];
out.b[2] = in.b[1];
out.b[3] = in.b[0];
return out.f;
}
float QCC_Float (float l)
{
return l;
}
void SetEndian(void)
{
union {qbyte b[2]; unsigned short s;} ed;
ed.s = 255;
if (ed.b[0] == 255)
{
PRBigShort = QCC_SwapShort;
PRLittleShort = QCC_Short;
PRBigLong = QCC_SwapLong;
PRLittleLong = QCC_Long;
PRBigFloat = QCC_SwapFloat;
PRLittleFloat = QCC_Float;
}
else
{
PRBigShort = QCC_Short;
PRLittleShort = QCC_SwapShort;
PRBigLong = QCC_Long;
PRLittleLong = QCC_SwapLong;
PRBigFloat = QCC_Float;
PRLittleFloat = QCC_SwapFloat;
}
}
void QC_strlcat(char *dest, const char *src, size_t destsize)
{
size_t curlen = strlen(dest);
if (!destsize)
return; //err
dest += curlen;
while(*src && ++curlen < destsize)
*dest++ = *src++;
// if (*src)
// printf("QC_strlcpy: truncation\n");
*dest = 0;
}
void QC_strlcpy(char *dest, const char *src, size_t destsize)
{
size_t curlen = 0;
if (!destsize)
return; //err
while(*src && ++curlen < destsize)
*dest++ = *src++;
// if (*src)
// printf("QC_strlcpy: truncation\n");
*dest = 0;
}
void QC_strnlcpy(char *dest, const char *src, size_t srclen, size_t destsize)
{
size_t curlen = 0;
if (!destsize)
return; //err
for(; *src && srclen > 0 && ++curlen < destsize; srclen--)
*dest++ = *src++;
// if (srclen)
// printf("QC_strlcpy: truncation\n");
*dest = 0;
}
char *QC_strcasestr(const char *haystack, const char *needle)
{
int i;
int matchamt=0;
for(i=0;haystack[i];i++)
{
if (tolower(haystack[i]) != tolower(needle[matchamt]))
matchamt = 0;
if (tolower(haystack[i]) == tolower(needle[matchamt]))
{
matchamt++;
if (needle[matchamt]==0)
return (char *)&haystack[i-(matchamt-1)];
}
}
return 0;
}
#if !defined(MINIMAL) && !defined(OMIT_QCC)
/*
================
I_FloatTime
================
*/
/*
double I_FloatTime (void)
{
struct timeval tp;
struct timezone tzp;
static int secbase;
gettimeofday(&tp, &tzp);
if (!secbase)
{
secbase = tp.tv_sec;
return tp.tv_usec/1000000.0;
}
return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
}
*/
#ifdef QCC
int QC_strncasecmp (const char *s1, const char *s2, int n)
{
int c1, c2;
while (1)
{
c1 = *s1++;
c2 = *s2++;
if (!n--)
return 0; // strings are equal until end point
if (c1 != c2)
{
if (c1 >= 'a' && c1 <= 'z')
c1 -= ('a' - 'A');
if (c2 >= 'a' && c2 <= 'z')
c2 -= ('a' - 'A');
if (c1 != c2)
return -1; // strings not equal
}
if (!c1)
return 0; // strings are equal
// s1++;
// s2++;
}
return -1;
}
int QC_strcasecmp (const char *s1, const char *s2)
{
return QC_strncasecmp(s1, s2, 0x7fffffff);
}
#else
int QC_strncasecmp(const char *s1, const char *s2, int n);
int QC_strcasecmp (const char *s1, const char *s2)
{
return QC_strncasecmp(s1, s2, 0x7fffffff);
}
#endif
#endif //minimal
/*
==============
COM_Parse
Parse a token out of a string
==============
*/
char *QCC_COM_Parse (const char *data)
{
int c;
int len;
len = 0;
qcc_token[0] = 0;
if (!data)
return NULL;
// skip whitespace
skipwhite:
while ((c = *data) && qcc_iswhite(c))
data++;
if (!c)
{
qcc_eof = true;
return NULL;
}
// skip // comments
if (c=='/' && data[1] == '/')
{
while (*data && *data != '\n')
data++;
goto skipwhite;
}
// skip /* comments
if (c=='/' && data[1] == '*')
{
while (data[1] && (data[0] != '*' || data[1] != '/'))
data++;
data+=2;
goto skipwhite;
}
// handle quoted strings specially
if (c == '\"')
{
data++;
do
{
c = *data++;
if (c=='\\' && *data == '\"')
c = *data++; //allow C-style string escapes
else if (c=='\\' && *data == '\\')
c = *data++; // \ is now a special character so it needs to be marked up using itself
else if (c=='\\' && *data == 'n')
{ // and do new lines while we're at it.
c = '\n';
data++;
}
else if (c=='\\' && *data == 'r')
{ // and do mac lines while we're at it.
c = '\r';
data++;
}
else if (c=='\\' && *data == 't')
{ // and do tabs while we're at it.
c = '\t';
data++;
}
else if (c=='\"')
{
qcc_token[len] = 0;
return (char*)data;
}
else if (c=='\0')
{
// printf("ERROR: Unterminated string\n");
qcc_token[len] = 0;
return (char*)data;
}
else if (c=='\n' || c=='\r')
{ //new lines are awkward.
//vanilla saved games do not add \ns on load
//terminating the string on a new line thus has compatbility issues.
//while "wad" "c:\foo\" does happen in the TF community (fucked tools)
//so \r\n terminates the string if the last char was an escaped quote, but not otherwise.
if (len > 0 && qcc_token[len-1] == '\"')
{
// printf("ERROR: new line in string\n");
qcc_token[len] = 0;
return (char*)data;
}
}
if (len >= sizeof(qcc_token)-1)
;
else
qcc_token[len] = c;
len++;
} while (1);
}
// parse single characters
if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':' || c==',')
{
qcc_token[len] = c;
len++;
qcc_token[len] = 0;
return (char*)data+1;
}
// parse a regular word
do
{
if (len >= sizeof(qcc_token)-1)
;
else
qcc_token[len++] = c;
data++;
c = *data;
if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':' || c=='\"' || c==',')
break;
} while (c && !qcc_iswhite(c));
qcc_token[len] = 0;
return (char*)data;
}
//more C tokens...
char *QCC_COM_Parse2 (char *data)
{
int c;
int len;
len = 0;
qcc_token[0] = 0;
if (!data)
return NULL;
// skip whitespace
skipwhite:
while ((c = *data) && qcc_iswhite(c))
data++;
if (!c)
{
qcc_eof = true;
return NULL;
}
// skip // comments
if (c=='/' && data[1] == '/')
{
while (*data && *data != '\n')
data++;
goto skipwhite;
}
// handle quoted strings specially
if (c == '\"')
{
data++;
do
{
c = *data++;
if (c=='\\' && *data == '\"')
c = *data++; //allow C-style string escapes
else if (c=='\\' && *data == '\\')
c = *data++; // \ is now a special character so it needs to be marked up using itself
else if (c=='\\' && *data == 'n')
{ // and do new lines while we're at it.
c = '\n';
data++;
}
else if (c=='\"'||c=='\0')
{
if (len < sizeof(qcc_token)-1)
qcc_token[len++] = 0;
break;
}
if (len >= sizeof(qcc_token)-1)
;
else
qcc_token[len++] = c;
} while (1);
}
// parse numbers
if (c >= '0' && c <= '9')
{
if (c == '0' && data[1] == 'x')
{ //parse hex
qcc_token[0] = '0';
c='x';
len=1;
data++;
for(;;)
{ //parse regular number
if (len >= sizeof(qcc_token)-1)
;
else
qcc_token[len++] = c;
data++;
c = *data;
if ((c<'0'|| c>'9') && (c<'a'||c>'f') && (c<'A'||c>'F') && c != '.')
break;
}
}
else
{
for(;;)
{ //parse regular number
if (len >= sizeof(qcc_token)-1)
;
else
qcc_token[len++] = c;
data++;
c = *data;
if ((c<'0'|| c>'9') && c != '.')
break;
}
}
qcc_token[len] = 0;
return data;
}
// parse words
else if ((c>= 'a' && c <= 'z') || (c>= 'A' && c <= 'Z') || c == '_')
{
do
{
if (len >= sizeof(qcc_token)-1)
;
else
qcc_token[len++] = c;
data++;
c = *data;
} while ((c>= 'a' && c <= 'z') || (c>= 'A' && c <= 'Z') || (c>= '0' && c <= '9') || c == '_');
qcc_token[len] = 0;
return data;
}
else
{
qcc_token[len] = c;
len++;
qcc_token[len] = 0;
return data+1;
}
}
char *VARGS qcva (char *text, ...)
{
va_list argptr;
static char msg[2048];
va_start (argptr,text);
QC_vsnprintf (msg,sizeof(msg)-1, text,argptr);
va_end (argptr);
return msg;
}
#if !defined(MINIMAL) && !defined(OMIT_QCC)
/*
=============================================================================
MISC FUNCTIONS
=============================================================================
*/
/*
=================
Error
For abnormal program terminations
=================
*/
void VARGS QCC_Error (int errortype, const char *error, ...)
{
progfuncs_t *progfuncs = qccprogfuncs;
extern int numsourcefiles;
va_list argptr;
char msg[2048];
va_start (argptr,error);
QC_vsnprintf (msg,sizeof(msg)-1, error,argptr);
va_end (argptr);
printf ("\n************ ERROR ************\n%s\n", msg);
editbadfile(s_filen, pr_source_line);
numsourcefiles = 0;
#ifndef QCC
longjmp(qcccompileerror, 1);
#else
print ("Press any key\n");
getch();
#endif
exit (1);
}
/*
=================
CheckParm
Checks for the given parameter in the program's command line arguments
Returns the argument number (1 to argc-1) or 0 if not present
=================
*/
int QCC_CheckParm (char *check)
{
int i;
for (i = 1;i<myargc;i++)
{
if ( !QC_strcasecmp(check, myargv[i]) )
return i;
}
return 0;
}
const char *QCC_ReadParm (char *check)
{
int i;
for (i = 1;i+1<myargc;i++)
{
if ( !QC_strcasecmp(check, myargv[i]) )
return myargv[i+1];
}
return 0;
}
/*
#ifndef O_BINARY
#define O_BINARY 0
#endif
#ifdef QCC
int SafeOpenWrite (char *filename)
{
int handle;
umask (0);
handle = open(filename,O_WRONLY | O_CREAT | O_TRUNC | O_BINARY
, 0666);
if (handle == -1)
QCC_Error ("Error opening %s: %s",filename,strerror(errno));
return handle;
}
#endif
int SafeOpenRead (char *filename)
{
int handle;
handle = open(filename,O_RDONLY | O_BINARY);
if (handle == -1)
QCC_Error ("Error opening %s: %s",filename,strerror(errno));
return handle;
}
void SafeRead (int handle, void *buffer, long count)
{
if (read (handle,buffer,count) != count)
QCC_Error ("File read failure");
}
#ifdef QCC
void SafeWrite (int handle, void *buffer, long count)
{
if (write (handle,buffer,count) != count)
QCC_Error ("File write failure");
}
#endif
void *SafeMalloc (long size)
{
void *ptr;
ptr = (void *)Hunk_Alloc (size);
if (!ptr)
QCC_Error ("Malloc failure for %lu bytes",size);
return ptr;
}
*/
void DefaultExtension (char *path, char *extension)
{
char *src;
//
// if path doesn't have a .EXT, append extension
// (extension should include the .)
//
src = path + strlen(path) - 1;
while (*src != PATHSEPERATOR && src != path)
{
if (*src == '.')
return; // it has an extension
src--;
}
strcat (path, extension);
}
void DefaultPath (char *path, char *basepath)
{
char temp[128];
if (path[0] == PATHSEPERATOR)
return; // absolute path location
strcpy (temp,path);
strcpy (path,basepath);
strcat (path,temp);
}
void StripFilename (char *path)
{
int length;
length = strlen(path)-1;
while (length > 0 && path[length] != PATHSEPERATOR)
length--;
path[length] = 0;
}
/*
====================
Extract file parts
====================
*/
void ExtractFilePath (char *path, char *dest)
{
char *src;
src = path + strlen(path) - 1;
//
// back up until a \ or the start
//
while (src != path && *(src-1) != PATHSEPERATOR)
src--;
memcpy (dest, path, src-path);
dest[src-path] = 0;
}
void ExtractFileBase (char *path, char *dest)
{
char *src;
src = path + strlen(path) - 1;
//
// back up until a \ or the start
//
while (src != path && *(src-1) != PATHSEPERATOR)
src--;
while (*src && *src != '.')
{
*dest++ = *src++;
}
*dest = 0;
}
void ExtractFileExtension (char *path, char *dest)
{
char *src;
src = path + strlen(path) - 1;
//
// back up until a . or the start
//
while (src != path && *(src-1) != '.')
src--;
if (src == path)
{
*dest = 0; // no extension
return;
}
strcpy (dest,src);
}
/*
==============
ParseNum / ParseHex
==============
*/
long ParseHex (char *hex)
{
char *str;
long num;
num = 0;
str = hex;
while (*str)
{
num <<= 4;
if (*str >= '0' && *str <= '9')
num += *str-'0';
else if (*str >= 'a' && *str <= 'f')
num += 10 + *str-'a';
else if (*str >= 'A' && *str <= 'F')
num += 10 + *str-'A';
else
QCC_Error (ERR_BADHEX, "Bad hex number: %s",hex);
str++;
}
return num;
}
long ParseNum (char *str)
{
if (str[0] == '$')
return ParseHex (str+1);
if (str[0] == '0' && str[1] == 'x')
return ParseHex (str+2);
return atol (str);
}
//buffer size and max size are different. buffer is bigger.
#define MAXQCCFILES 3
struct {
char *name;
FILE *stdio;
char *buff;
int buffsize;
int ofs;
int maxofs;
} qccfile[MAXQCCFILES];
int SafeOpenWrite (char *filename, int maxsize)
{
int i;
for (i = 0; i < MAXQCCFILES; i++)
{
if (!qccfile[i].stdio && !qccfile[i].buff)
{
qccfile[i].name = strdup(filename);
qccfile[i].buffsize = maxsize;
qccfile[i].maxofs = 0;
qccfile[i].ofs = 0;
qccfile[i].stdio = NULL;
qccfile[i].buff = NULL;
if (maxsize < 0)
qccfile[i].stdio = fopen(filename, "wb");
else
qccfile[i].buff = malloc(qccfile[i].buffsize);
if (!qccfile[i].stdio && !qccfile[i].buff)
{
QCC_Error(ERR_TOOMANYOPENFILES, "Unable to open %s", filename);
return -1;
}
return i;
}
}
QCC_Error(ERR_TOOMANYOPENFILES, "Too many open files on file %s", filename);
return -1;
}
void ResizeBuf(int hand, int newsize)
{
char *nb;
if (qccfile[hand].buffsize >= newsize)
return; //already big enough
nb = malloc(newsize);
memcpy(nb, qccfile[hand].buff, qccfile[hand].maxofs);
free(qccfile[hand].buff);
qccfile[hand].buff = nb;
qccfile[hand].buffsize = newsize;
}
void SafeWrite(int hand, const void *buf, long count)
{
if (qccfile[hand].stdio)
{
fwrite(buf, 1, count, qccfile[hand].stdio);
}
else
{
if (qccfile[hand].ofs +count >= qccfile[hand].buffsize)
ResizeBuf(hand, qccfile[hand].ofs + count+(64*1024));
memcpy(&qccfile[hand].buff[qccfile[hand].ofs], buf, count);
}
qccfile[hand].ofs+=count;
if (qccfile[hand].ofs > qccfile[hand].maxofs)
qccfile[hand].maxofs = qccfile[hand].ofs;
}
int SafeSeek(int hand, int ofs, int mode)
{
if (mode == SEEK_CUR)
return qccfile[hand].ofs;
else
{
if (qccfile[hand].stdio)
fseek(qccfile[hand].stdio, ofs, SEEK_SET);
else
ResizeBuf(hand, ofs+1024);
qccfile[hand].ofs = ofs;
if (qccfile[hand].ofs > qccfile[hand].maxofs)
qccfile[hand].maxofs = qccfile[hand].ofs;
return 0;
}
}
pbool SafeClose(int hand)
{
progfuncs_t *progfuncs = qccprogfuncs;
pbool ret;
if (qccfile[hand].stdio)
ret = 0==fclose(qccfile[hand].stdio);
else
{
ret = externs->WriteFile(qccfile[hand].name, qccfile[hand].buff, qccfile[hand].maxofs);
free(qccfile[hand].buff);
}
free(qccfile[hand].name);
qccfile[hand].name = NULL;
qccfile[hand].buff = NULL;
qccfile[hand].stdio = NULL;
return ret;
}
qcc_cachedsourcefile_t *qcc_sourcefile;
//return 0 if the input is not valid utf-8.
unsigned int utf8_check(const void *in, unsigned int *value)
{
//uc is the output unicode char
unsigned int uc = 0xfffdu; //replacement character
const unsigned char *str = in;
if (!(*str & 0x80))
{
*value = *str;
return 1;
}
else if ((*str & 0xe0) == 0xc0)
{
if ((str[1] & 0xc0) == 0x80)
{
*value = uc = ((str[0] & 0x1f)<<6) | (str[1] & 0x3f);
if (!uc || uc >= (1u<<7)) //allow modified utf-8
return 2;
}
}
else if ((*str & 0xf0) == 0xe0)
{
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80)
{
*value = uc = ((str[0] & 0x0f)<<12) | ((str[1] & 0x3f)<<6) | ((str[2] & 0x3f)<<0);
if (uc >= (1u<<11))
return 3;
}
}
else if ((*str & 0xf8) == 0xf0)
{
if ((str[1] & 0xc0) == 0x80 && (str[2] & 0xc0) == 0x80 && (str[3] & 0xc0) == 0x80)
{
*value = uc = ((str[0] & 0x07)<<18) | ((str[1] & 0x3f)<<12) | ((str[2] & 0x3f)<<6) | ((str[3] & 0x3f)<<0);
if (uc >= (1u<<16)) //overlong
if (uc <= 0x10ffff) //aand we're not allowed to exceed utf-16 surrogates.
return 4;
}
}
*value = 0xFFFD;
return 0;
}
//read utf-16 chars and output the 'native' utf-8.
//we don't expect essays written in code, so we don't need much actual support for utf-8.
static char *decodeUTF(int type, unsigned char *inputf, size_t inbytes, size_t *outlen, pbool usemalloc)
{
char *utf8, *start;
unsigned int inc;
unsigned int chars, i;
int w, maxperchar;
switch(type)
{
case UTF16LE:
w = 2;
maxperchar = 4;
break;
case UTF16BE:
w = 2;
maxperchar = 4;
break;
case UTF32LE:
w = 4;
maxperchar = 4; //we adhere to RFC3629 and clamp to U+10FFFF, which is only 4 bytes.
break;
case UTF32BE:
w = 4;
maxperchar = 4;
break;
default:
//error
*outlen = 0;
return NULL;
}
chars = inbytes / w;
if (usemalloc)
utf8 = start = malloc(chars * maxperchar + 2+1);
else
utf8 = start = qccHunkAlloc(chars * maxperchar + 2+1);
for (i = 0; i < chars; i++)
{
switch(type)
{
default:
inc = 0;
break;
case UTF16LE:
case UTF16BE:
inc = inputf[type==UTF16BE];
inc|= inputf[type==UTF16LE]<<8;
inputf += 2;
//handle surrogates
if (inc >= 0xd800u && inc < 0xdc00u && i+1 < chars)
{
unsigned int l;
l = inputf[type==UTF16BE];
l|= inputf[type==UTF16LE]<<8;
if (l >= 0xdc00u && l < 0xe000u)
{
inputf+=2;
inc = (((inc & 0x3ffu)<<10) | (l & 0x3ffu)) + 0x10000;
i++;
}
}
break;
case UTF32LE:
inc = *inputf++;
inc|= (*inputf++)<<8;
inc|= (*inputf++)<<16;
inc|= (*inputf++)<<24;
break;
case UTF32BE:
inc = (*inputf++)<<24;
inc|= (*inputf++)<<16;
inc|= (*inputf++)<<8;
inc|= *inputf++;
break;
}
if (inc > 0x10FFFF)
inc = 0xFFFD;
if (inc <= 127)
*utf8++ = inc;
else if (inc <= 0x7ff)
{
*utf8++ = ((inc>>6) & 0x1f) | 0xc0;
*utf8++ = ((inc>>0) & 0x3f) | 0x80;
}
else if (inc <= 0xffff)
{
*utf8++ = ((inc>>12) & 0xf) | 0xe0;
*utf8++ = ((inc>>6) & 0x3f) | 0x80;
*utf8++ = ((inc>>0) & 0x3f) | 0x80;
}
else if (inc <= 0x1fffff)
{
*utf8++ = ((inc>>18) & 0x07) | 0xf0;
*utf8++ = ((inc>>12) & 0x3f) | 0x80;
*utf8++ = ((inc>> 6) & 0x3f) | 0x80;
*utf8++ = ((inc>> 0) & 0x3f) | 0x80;
}
else
{
inc = 0xFFFD;
*utf8++ = ((inc>>12) & 0xf) | 0xe0;
*utf8++ = ((inc>>6) & 0x3f) | 0x80;
*utf8++ = ((inc>>0) & 0x3f) | 0x80;
}
}
*outlen = utf8 - start;
*utf8 = 0;
return start;
}
//the gui is a windows program.
//this means that its fucked.
//on the plus side, its okay with a bom...
unsigned short *QCC_makeutf16(char *mem, size_t len, int *outlen, pbool *errors)
{
unsigned int code;
int l;
unsigned short *out, *outstart;
pbool nonascii = false;
//sanitise the input.
if (len >= 4 && mem[0] == '\xff' && mem[1] == '\xfe' && mem[2] == '\x00' && mem[3] == '\x00')
mem = decodeUTF(UTF32LE, (unsigned char*)mem+4, len-4, &len, true);
else if (len >= 4 && mem[0] == '\x00' && mem[1] == '\x00' && mem[2] == '\xfe' && mem[3] == '\xff')
mem = decodeUTF(UTF32BE, (unsigned char*)mem+4, len-4, &len, true);
else if (len >= 2 && mem[0] == '\xff' && mem[1] == '\xfe')
{
//already utf8, just return it as-is
out = malloc(len+3);
memcpy(out, mem, len);
out[len/2] = 0;
return out;
//mem = decodeUTF(UTF16LE, (unsigned char*)mem+2, len-2, &len, false);
}
else if (len >= 2 && mem[0] == '\xfe' && mem[1] == '\xff')
mem = decodeUTF(UTF16BE, (unsigned char*)mem+2, len-2, &len, false);
//utf-8 BOM, for compat with broken text editors (like windows notepad).
else if (len >= 3 && mem[0] == '\xef' && mem[1] == '\xbb' && mem[2] == '\xbf')
{
mem += 3;
len -= 3;
}
outstart = malloc(len*2+3);
out = outstart;
while(len)
{
l = utf8_check(mem, &code);
if (!l)
{l = 1; code = 0xe000|(unsigned char)*mem; nonascii = true;}//fucked up. convert to 0xe000 private-use range.
len -= l;
mem += l;
if (code > 0xffff)
{
code -= 0x10000;
*out++ = 0xd800u | ((code>>10) & 0x3ff);
// *out++ = 0xdc00u | ((code>>00) & 0x3ff);
}
else
*out++ = code;
}
if (outlen)
*outlen = out - outstart;
*out++ = 0;
if (errors)
*errors = nonascii;
return outstart;
}
//input is a raw file (will not be changed
//output is utf-8 data
char *QCC_SanitizeCharSet(char *mem, size_t *len, pbool *freeresult, int *origfmt)
{
if (freeresult)
*freeresult = true;
if (*len >= 4 && mem[0] == '\xff' && mem[1] == '\xfe' && mem[2] == '\x00' && mem[3] == '\x00')
mem = decodeUTF(*origfmt=UTF32LE, (unsigned char*)mem+4, *len-4, len, !!freeresult);
else if (*len >= 4 && mem[0] == '\x00' && mem[1] == '\x00' && mem[2] == '\xfe' && mem[3] == '\xff')
mem = decodeUTF(*origfmt=UTF32BE, (unsigned char*)mem+4, *len-4, len, !!freeresult);
else if (*len >= 2 && mem[0] == '\xff' && mem[1] == '\xfe')
mem = decodeUTF(*origfmt=UTF16LE, (unsigned char*)mem+2, *len-2, len, !!freeresult);
else if (*len >= 2 && mem[0] == '\xfe' && mem[1] == '\xff')
mem = decodeUTF(*origfmt=UTF16BE, (unsigned char*)mem+2, *len-2, len, !!freeresult);
//utf-8 BOM, for compat with broken text editors (like windows notepad).
else if (*len >= 3 && mem[0] == '\xef' && mem[1] == '\xbb' && mem[2] == '\xbf')
{
*origfmt=UTF8_BOM;
mem += 3;
*len -= 3;
if (freeresult)
*freeresult = false;
}
else
{
unsigned int ch, cl;
char *p, *e=mem+*len;
*origfmt=UTF8_RAW;
for (p = mem; p < e; p += cl) //validate it, so we're sure what format it actually is
{
cl = utf8_check(p, &ch);
if (!cl)
{
*origfmt = UTF_ANSI;
break;
}
}
if (freeresult)
*freeresult = false;
/*
#ifdef _WIN32
//even if we wrote the bom, resaving with wordpad will translate the file to the system's active code page, which will fuck up any comments. thanks for that, wordpad.
//(weirdly, notepad does the right thing)
int wchars = MultiByteToWideChar(CP_ACP, 0, mem, *len, NULL, 0);
if (wchars)
{
BOOL failed = false;
wchar_t *wc = malloc(wchars * sizeof(wchar_t));
int mchars;
MultiByteToWideChar(CP_ACP, 0, mem, *len, wc, wchars);
mchars = WideCharToMultiByte(CP_UTF8, 0, wc, wchars, NULL, 0, NULL, NULL);
if (mchars && !failed)
{
mem = (freeresult?malloc(mchars+2):qccHunkAlloc(mchars+2));
mem[mchars] = 0;
*len = mchars;
if (freeresult)
*freeresult = true;
WideCharToMultiByte(CP_UTF8, 0, wc, wchars, mem, mchars, NULL, NULL);
}
free(wc);
}
#endif
*/
}
return mem;
}
static unsigned char *PDECL QCC_LoadFileHunk(void *ctx, size_t size)
{ //2 ensures we can always put a \n in there.
return (unsigned char*)qccHunkAlloc(sizeof(qcc_cachedsourcefile_t)+strlen(ctx)+size+2) + sizeof(qcc_cachedsourcefile_t) + strlen(ctx);
}
long QCC_LoadFile (char *filename, void **bufferptr)
{
qcc_cachedsourcefile_t *sfile;
progfuncs_t *progfuncs = qccprogfuncs;
char *mem;
int check;
size_t len;
int line;
int orig;
pbool warned = false;
mem = externs->ReadFile(filename, QCC_LoadFileHunk, filename, &len, true);
if (!mem)
{
QCC_Error(ERR_COULDNTOPENFILE, "Couldn't open file %s", filename);
return -1;
}
sfile = (qcc_cachedsourcefile_t*)(mem-sizeof(qcc_cachedsourcefile_t)-strlen(filename));
mem[len] = 0;
mem = QCC_SanitizeCharSet(mem, &len, NULL, &orig);
//actual utf-8 handling is somewhat up to the engine. the qcc can only ensure that utf8 works in symbol names etc.
//its only in strings where it actually makes a difference, and the interpretation of those is basically entirely up to the engine.
//that said, we could insert a utf-8 BOM into ones with utf-8 chars, but that would mess up a lot of builtins+mods, so we won't.
for (check = 0, line = 1; check < len; check++)
{
if (mem[check] == '\n')
line++;
else if (!mem[check])
{
if (!warned)
QCC_PR_Warning(WARN_UNEXPECTEDPUNCT, filename, line, "file contains null bytes %u/%u", check, len);
warned = true;
//fixme: insert modified-utf-8 nulls instead.
mem[check] = ' ';
}
}
mem[len] = '\n';
mem[len+1] = '\0';
strcpy(sfile->filename, filename);
sfile->size = len;
sfile->file = mem;
sfile->type = FT_CODE;
sfile->next = qcc_sourcefile;
qcc_sourcefile = sfile;
*bufferptr=mem;
return len;
}
void QCC_AddFile (char *filename)
{
qcc_cachedsourcefile_t *sfile;
progfuncs_t *progfuncs = qccprogfuncs;
char *mem;
size_t len;
mem = externs->ReadFile(filename, QCC_LoadFileHunk, filename, &len, false);
if (!mem)
externs->Abort("failed to find file %s", filename);
sfile = (qcc_cachedsourcefile_t*)(mem-sizeof(qcc_cachedsourcefile_t)-strlen(filename));
mem[len] = '\0';
sfile->size = len;
strcpy(sfile->filename, filename);
sfile->file = mem;
sfile->type = FT_DATA;
sfile->next = qcc_sourcefile;
qcc_sourcefile = sfile;
}
static unsigned char *PDECL FS_ReadToMem_Alloc(void *ctx, size_t size)
{
unsigned char *mem;
progfuncs_t *progfuncs = qccprogfuncs;
mem = externs->memalloc(size+1);
mem[size] = 0;
return mem;
}
void *FS_ReadToMem(char *filename, size_t *len)
{
progfuncs_t *progfuncs = qccprogfuncs;
return externs->ReadFile(filename, FS_ReadToMem_Alloc, NULL, len, false);
}
void FS_CloseFromMem(void *mem)
{
progfuncs_t *progfuncs = qccprogfuncs;
externs->memfree(mem);
}
#endif
void StripExtension (char *path)
{
int length;
length = strlen(path)-1;
while (length > 0 && path[length] != '.')
{
length--;
if (path[length] == '/')
return; // no extension
}
if (length)
path[length] = 0;
}
Reference in a new issue View git blame Copy permalink