darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2025-02-17 09:02:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix FTFBS stuff

Browse source
This commit is contained in:
Dale Weiler 2012-12-19 21:05:24 +00:00
parent 664b6d6604
commit 2cc51b8eb0
5 changed files with 25 additions and 69 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
gmqcc.h
View file

@ -175,13 +175,7 @@
typedef struct { char _fail : 0; } int64_t; typedef struct { char _fail : 0; } int64_t;
typedef struct { char _fail : 0; } uint64_t; typedef struct { char _fail : 0; } uint64_t;
#endif #endif
#ifdef _LP64 /* long pointer == 64 */
typedef unsigned long uintptr_t;
typedef long intptr_t;
#else
typedef unsigned int uintptr_t;
typedef int intptr_t;
#endif
/* Ensure type sizes are correct: */ /* Ensure type sizes are correct: */
typedef char uint8_size_is_correct [sizeof(uint8_t) == 1?1:-1]; typedef char uint8_size_is_correct [sizeof(uint8_t) == 1?1:-1];
typedef char uint16_size_is_correct [sizeof(uint16_t) == 2?1:-1]; typedef char uint16_size_is_correct [sizeof(uint16_t) == 2?1:-1];
@ -190,10 +184,6 @@ typedef char uint64_size_is_correct [sizeof(uint64_t) == 8?1:-1];
typedef char int16_size_if_correct [sizeof(int16_t) == 2?1:-1]; typedef char int16_size_if_correct [sizeof(int16_t) == 2?1:-1];
typedef char int32_size_is_correct [sizeof(int32_t) == 4?1:-1]; typedef char int32_size_is_correct [sizeof(int32_t) == 4?1:-1];
typedef char int64_size_is_correct [sizeof(int64_t) >= 8?1:-1]; typedef char int64_size_is_correct [sizeof(int64_t) >= 8?1:-1];
/* intptr_t / uintptr_t correct size check */
typedef char uintptr_size_is_correct[sizeof(intptr_t) == sizeof(int*)?1:-1];
typedef char intptr_size_is_correct [sizeof(uintptr_t)== sizeof(int*)?1:-1];
/*===================================================================*/ /*===================================================================*/
/*=========================== util.c ================================*/ /*=========================== util.c ================================*/
/*===================================================================*/ /*===================================================================*/

4
ir.c
View file

@ -3542,8 +3542,8 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
#define IND_BUFSZ 1024 #define IND_BUFSZ 1024
#ifdef WIN32 #ifdef _MSC_VER
# define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE) # define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
#endif #endif
const char *qc_opname(int op) const char *qc_opname(int op)

1
opts.def
View file

@ -39,7 +39,6 @@
GMQCC_DEFINE_FLAG(ASSIGN_FUNCTION_TYPES) GMQCC_DEFINE_FLAG(ASSIGN_FUNCTION_TYPES)
GMQCC_DEFINE_FLAG(LNO) GMQCC_DEFINE_FLAG(LNO)
GMQCC_DEFINE_FLAG(CORRECT_TERNARY) GMQCC_DEFINE_FLAG(CORRECT_TERNARY)
GMQCC_DEFINE_FLAG(SINGLE_VECTOR_DEFS)
#endif #endif
/* warning flags */ /* warning flags */

75
parser.c
View file

@ -98,8 +98,6 @@ typedef struct {
bool noref; bool noref;
} parser_t; } parser_t;
static const ast_expression *intrinsic_debug_typestring = (ast_expression*)0x10;
static void parser_enterblock(parser_t *parser); static void parser_enterblock(parser_t *parser);
static bool parser_leaveblock(parser_t *parser); static bool parser_leaveblock(parser_t *parser);
static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e); static void parser_addlocal(parser_t *parser, const char *name, ast_expression *e);
@ -837,19 +835,13 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
return false; return false;
} }
#endif #endif
if (opts.standard == COMPILER_GMQCC)
con_out("TODO: early out logic\n");
if (CanConstFold(exprs[0], exprs[1])) if (CanConstFold(exprs[0], exprs[1]))
out = (ast_expression*)parser_const_float(parser, out = (ast_expression*)parser_const_float(parser,
(generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1)))); (generated_op == INSTR_OR ? (ConstF(0) || ConstF(1)) : (ConstF(0) && ConstF(1))));
else else
{
if (OPTS_FLAG(PERL_LOGIC) && !ast_compare_type(exprs[0], exprs[1])) {
ast_type_to_string(exprs[0], ty1, sizeof(ty1));
ast_type_to_string(exprs[1], ty2, sizeof(ty2));
parseerror(parser, "invalid types for logical operation with -fperl-logic: %s and %s", ty1, ty2);
return false;
}
out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]); out = (ast_expression*)ast_binary_new(ctx, generated_op, exprs[0], exprs[1]);
}
break; break;
case opid2('?',':'): case opid2('?',':'):
@ -1200,25 +1192,9 @@ static bool parser_close_call(parser_t *parser, shunt *sy)
fun = sy->out[fid].out; fun = sy->out[fid].out;
if (fun == intrinsic_debug_typestring) {
char ty[1024];
if (fid+2 != vec_size(sy->out) ||
vec_last(sy->out).block)
{
parseerror(parser, "intrinsic __builtin_debug_typestring requires exactly 1 parameter");
return false;
}
ast_type_to_string(vec_last(sy->out).out, ty, sizeof(ty));
ast_unref(vec_last(sy->out).out);
sy->out[fid] = syexp(ast_ctx(vec_last(sy->out).out),
(ast_expression*)parser_const_string(parser, ty, false));
vec_shrinkby(sy->out, 1);
return true;
}
call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun); call = ast_call_new(sy->ops[vec_size(sy->ops)].ctx, fun);
if (!call) { if (!call) {
parseerror(parser, "internal error: failed to create ast_call node"); parseerror(parser, "out of memory");
return false; return false;
} }
@ -1275,9 +1251,9 @@ static bool parser_close_call(parser_t *parser, shunt *sy)
fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line); fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
else else
parseerror(parser, "too %s parameters for function call: expected %i, got %i\n" parseerror(parser, "too %s parameters for function call: expected %i, got %i\n"
" -> it has been declared here: %s:%i", " -> `%s` has been declared here: %s:%i",
fewmany, (int)vec_size(fun->expression.params), (int)paramcount, fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount,
ast_ctx(fun).file, (int)ast_ctx(fun).line); fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
return false; return false;
} }
else else
@ -1291,9 +1267,9 @@ static bool parser_close_call(parser_t *parser, shunt *sy)
else else
return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS, return !parsewarning(parser, WARN_TOO_FEW_PARAMETERS,
"too %s parameters for function call: expected %i, got %i\n" "too %s parameters for function call: expected %i, got %i\n"
" -> it has been declared here: %s:%i", " -> `%s` has been declared here: %s:%i",
fewmany, (int)vec_size(fun->expression.params), (int)paramcount, fewmany, fval->name, (int)vec_size(fun->expression.params), (int)paramcount,
ast_ctx(fun).file, (int)ast_ctx(fun).line); fval->name, ast_ctx(fun).file, (int)ast_ctx(fun).line);
} }
} }
} }
@ -1456,27 +1432,16 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
var = parser_find_field(parser, parser_tokval(parser)); var = parser_find_field(parser, parser_tokval(parser));
} }
if (!var) { if (!var) {
/* intrinsics */ parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
if (!strcmp(parser_tokval(parser), "__builtin_debug_typestring")) { goto onerr;
var = (ast_expression*)intrinsic_debug_typestring;
}
else
{
parseerror(parser, "unexpected ident: %s", parser_tokval(parser));
goto onerr;
}
} }
else if (ast_istype(var, ast_value)) {
{ ((ast_value*)var)->uses++;
if (ast_istype(var, ast_value)) { }
((ast_value*)var)->uses++; else if (ast_istype(var, ast_member)) {
} ast_member *mem = (ast_member*)var;
else if (ast_istype(var, ast_member)) { if (ast_istype(mem->owner, ast_value))
ast_member *mem = (ast_member*)var; ((ast_value*)(mem->owner))->uses++;
if (ast_istype(mem->owner, ast_value))
((ast_value*)(mem->owner))->uses++;
}
} }
vec_push(sy.out, syexp(parser_ctx(parser), var)); vec_push(sy.out, syexp(parser_ctx(parser), var));
DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser))); DEBUGSHUNTDO(con_out("push %s\n", parser_tokval(parser)));
@ -1698,6 +1663,7 @@ static ast_expression* parse_expression_leave(parser_t *parser, bool stopatcomma
vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0)); vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_INDEX, 0));
wantop = false; wantop = false;
} else if (op->id == opid2('?',':')) { } else if (op->id == opid2('?',':')) {
wantop = false;
vec_push(sy.ops, syop(parser_ctx(parser), op)); vec_push(sy.ops, syop(parser_ctx(parser), op));
vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0)); vec_push(sy.ops, syparen(parser_ctx(parser), SY_PAREN_TERNARY, 0));
wantop = false; wantop = false;
@ -2342,7 +2308,8 @@ static bool parse_switch(parser_t *parser, ast_block *block, ast_expression **ou
return false; return false;
} }
if (!OPTS_FLAG(RELAXED_SWITCH)) { if (!OPTS_FLAG(RELAXED_SWITCH)) {
if (!ast_istype(swcase.value, ast_value)) { /* || ((ast_value*)swcase.value)->cvq != CV_CONST) { */ opval = (ast_value*)swcase.value;
if (!ast_istype(swcase.value, ast_value)) { /* || opval->cvq != CV_CONST) { */
parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch"); parseerror(parser, "case on non-constant values need to be explicitly enabled via -frelaxed-switch");
ast_unref(operand); ast_unref(operand);
return false; return false;

2
util.c
View file

@ -495,7 +495,7 @@ size_t util_strtononcmd(const char *in, char *out, size_t outsz) {
FILE *util_fopen(const char *filename, const char *mode) FILE *util_fopen(const char *filename, const char *mode)
{ {
#ifdef WIN32 #ifdef _MSC_VER
FILE *out; FILE *out;
if (fopen_s(&out, filename, mode) != 0) if (fopen_s(&out, filename, mode) != 0)
return NULL; return NULL;