darkplaces/gmqcc
0
0
Fork 0
mirror of https://github.com/DarkPlacesEngine/gmqcc.git synced 2024-11-23 12:22:26 +00:00
Code Issues Projects Releases Packages Wiki Activity

Please the whitespace gods

Browse source
This commit is contained in:
Dale Weiler 2013-07-27 11:48:55 +00:00
parent 8db9724c5d
commit c7679722fb
6 changed files with 25 additions and 25 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
ast.c
View file

@ -1185,7 +1185,7 @@ ast_function* ast_function_new(lex_ctx ctx, const char *name, ast_value *vtype)
self->return_value = NULL;
return self;
cleanup:
mem_d(self);
return NULL;
@ -2884,12 +2884,12 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value
/* From 'bin' we jump to whatever comes first */
if (bprecond) tmpblock = bprecond;
else tmpblock = bbody; /* can never be null */
/* DEAD CODE
else if (bpostcond) tmpblock = bpostcond;
else tmpblock = bout;
*/
if (!ir_block_create_jump(bin, ast_ctx(self), tmpblock))
return false;
@ -2899,7 +2899,7 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value
ir_block *ontrue, *onfalse;
ontrue = bbody; /* can never be null */
/* all of this is dead code
/* all of this is dead code
else if (bincrement) ontrue = bincrement;
else ontrue = bpostcond;
*/
@ -2943,7 +2943,7 @@ bool ast_loop_codegen(ast_loop *self, ast_function *func, bool lvalue, ir_value
if (bprecond) ontrue = bprecond;
else ontrue = bbody; /* can never be null */
/* all of this is dead code
/* all of this is dead code
else if (bincrement) ontrue = bincrement;
else ontrue = bpostcond;
*/

10
ir.c
View file

@ -1807,21 +1807,21 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx,
default:
/* ranges: */
/* boolean operations result in floats */
/*
* opcode >= 10 takes true branch opcode is at least 10
* opcode <= 23 takes false branch opcode is at least 24
*/
if (opcode >= INSTR_EQ_F && opcode <= INSTR_GT)
ot = TYPE_FLOAT;
/*
* At condition "opcode <= 23", the value of "opcode" must be
/*
* At condition "opcode <= 23", the value of "opcode" must be
* at least 24.
* At condition "opcode <= 23", the value of "opcode" cannot be
* equal to any of {1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65}.
* The condition "opcode <= 23" cannot be true.
*
*
* Thus ot=2 (TYPE_FLOAT) can never be true
*/
#if 0

2
ir.h
View file

@ -267,7 +267,7 @@ typedef struct ir_builder_s
/* there should just be this one nil */
ir_value *nil;
ir_value *reserved_va_count;
/* code generator */
code_t *code;
} ir_builder;

2
main.c
View file

@ -682,7 +682,7 @@ int main(int argc, char **argv) {
if (!line[0] || (line[0] == '/' && line[1] == '/'))
continue;
if (hasline) {
item.filename = util_strdup(line);
item.type = TYPE_QC;

14
parser.c
View file

@ -1042,20 +1042,20 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
* Further more, the only time it is legal to do XOR otherwise
* is when both operand are floats. This nicely crafted if
* statement catches them all.
*
*
* In the event that the first operand is a vector, two
* possible situations can arise, thus, each element of
* vector A (operand A) is exclusive-ORed with the corresponding
* element of vector B (operand B), If B is scalar, the
* scalar value is first replicated for each element.
*
*
* The QCVM itself lacks a BITXOR instruction. Thus emulating
* the mathematics of it is required. The following equation
* is used: (LHS | RHS) & ~(LHS & RHS). However, due to the
* QCVM also lacking a BITNEG instruction, we need to emulate
* ~FOO with -1 - FOO, the whole process becoming this nicely
* crafted expression: (LHS | RHS) & (-1 - (LHS & RHS)).
*
*
* When A is not scalar, this process is repeated for all
* components of vector A with the value in operand B,
* only if operand B is scalar. When A is not scalar, and B
@ -1063,7 +1063,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
* components of the vector A with the components of vector B.
* Finally when A is scalar and B is scalar, this process is
* simply used once for A and B being LHS and RHS respectfully.
*
*
* Yes the semantics are a bit strange (no pun intended).
* But then again BITXOR is strange itself, consdering it's
* commutative, assocative, and elements of the BITXOR operation
@ -1099,7 +1099,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
)
);
expr->refs = AST_REF_NONE;
out = (ast_expression*)
ast_binary_new(
ctx,
@ -1152,7 +1152,7 @@ static bool parser_sy_apply_operator(parser_t *parser, shunt *sy)
}
}
}
break;
case opid2('<','<'):
@ -6463,7 +6463,7 @@ static void parser_remove_ast(parser_t *parser)
ast_value_delete(parser->const_vec[0]);
ast_value_delete(parser->const_vec[1]);
ast_value_delete(parser->const_vec[2]);
if (parser->reserved_version)
ast_value_delete(parser->reserved_version);

12
stat.c
View file

@ -276,20 +276,20 @@ typedef struct hash_node_t {
* This is a patched version of the Murmur2 hashing function to use
* a proper pre-mix and post-mix setup. Infact this is Murmur3 for
* the most part just reinvented.
*
*
* Murmur 2 contains an inner loop such as:
* while (l >= 4) {
* u32 k = *(u32*)d;
* k *= m;
* k ^= k >> r;
* k *= m;
*
*
* h *= m;
* h ^= k;
* d += 4;
* l -= 4;
* }
*
*
* The two u32s that form the key are the same value x (pulled from data)
* this premix stage will perform the same results for both values. Unrolled
* this produces just:
@ -301,18 +301,18 @@ typedef struct hash_node_t {
* h ^= x;
* h *= m;
* h ^= x;
*
*
* This appears to be fine, except what happens when m == 1? well x
* cancels out entierly, leaving just:
* x ^= x >> r;
* h ^= x;
* h ^= x;
*
*
* So all keys hash to the same value, but how often does m == 1?
* well, it turns out testing x for all possible values yeilds only
* 172,013,942 unique results instead of 2^32. So nearly ~4.6 bits
* are cancelled out on average!
*
*
* This means we have a 14.5% (rounded) chance of colliding more, which
* results in another bucket/chain for the hashtable.
*