void SqlCompiler::checkExpressionType(InsertColumnExpression &col) {
const SyntaxNode *p = findFirstTableReference(col.m_expr);
if(p != NULL)
syntaxError(p,SQL_INVALID_EXPR_TYPE,_T("Columnnames not allowed in valuelist"));
p = findFirstAggregateFunction(col.m_expr);
if(p != NULL)
syntaxError(p,SQL_INVALID_EXPR_TYPE,_T("Aggregation not allowed in valuelist"));
DbMainType exprtype = checkValueExpressionMainType(col.m_expr);
DbMainType coltype = getMainType(col.getType());
if(!isCompatibleType(exprtype,coltype)) {
switch(coltype) {
case MAINTYPE_NUMERIC :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be numeric"));
break;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be String"));
break;
case MAINTYPE_DATE :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be Date"));
break;
case MAINTYPE_TIME :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be time"));
break;
case MAINTYPE_TIMESTAMP:
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be Timestamp"));
break;
default :
stopcomp(col.m_expr);
}
}
}
SyntaxNode *SqlCompiler::fetchDefaultValueNode(const ColumnDefinition &col) {
if(col.m_defaultValue.length() == 0) { // has no default-value
if(col.m_nullAllowed)
return fetchTokenNode(NULLVAL,NULL);
else
return NULL; // no default, nulls not allowed. i.e. syntaxError !
}
else { // defaultvalue specified. now find the type an return a syntaxnode of the right type
switch(getMainType(col.getType())) {
case MAINTYPE_NUMERIC :
return fetchNumberNode(_ttof(col.m_defaultValue.cstr()));
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR :
return fetchStringNode(col.m_defaultValue.cstr());
case MAINTYPE_DATE :
return fetchDateNode(Date(col.m_defaultValue.cstr()));
case MAINTYPE_TIME :
return fetchTimeNode(Time(col.m_defaultValue.cstr()));
case MAINTYPE_TIMESTAMP:
return fetchTimestampNode(Timestamp(col.m_defaultValue.cstr()));
default :
throwSqlError(SQL_FATAL_ERROR,_T("Unexpected datatype in fetchDefaultValueNode:%d col:<%s>\n"),col.getType(),col.m_name.cstr());
return NULL; // to make compiler happy
}
}
}
bool PedInstance::createActQFindEnemy(actionQueueGroupType &as) {
as.state = 1;
actionQueueType aq;
aq.as = PedInstance::pa_smNone;
aq.group_desc = PedInstance::gd_mThink;
aq.state = 1;
aq.ot_execute = PedInstance::ai_aFindEnemy;
as.actions.push_back(aq);
pedWeaponToUse pw_to_use;
Mod *pMod = slots_[Mod::MOD_BRAIN];
if (getMainType() == PedInstance::m_tpAgent) {
aq.multi_var.enemy_var.pw_to_use.use_ranks = pMod || (!isOurAgent())
? true: false;
WeaponInstance *wi = selectedWeapon();
if (wi && wi->usesAmmo() && wi->ammoRemaining() == 0) {
wi = NULL;
setSelectedWeapon(-1);
}
if (wi && wi->canShoot()) {
if (pMod) {
// This overrides selected weapon
// might be confusing for player
if (pMod->getVersion() == Mod::MOD_V3) {
pw_to_use.desc = 5;
pw_to_use.wpn.dmg_type = wi->dmgType();
} else if (pMod->getVersion() == Mod::MOD_V2) {
pw_to_use.desc = 4;
pw_to_use.wpn.dmg_type = wi->dmgType();
} else {
// Mod::MOD_V1
pw_to_use.desc = 3;
pw_to_use.wpn.wpn_type = wi->getWeaponType();
}
} else {
pw_to_use.desc = 2;
pw_to_use.wpn.wi = wi;
}
} else {
pw_to_use.desc = 5;
pw_to_use.wpn.dmg_type = MapObject::dmg_Physical;
}
} else {
pw_to_use.desc = 5;
pw_to_use.wpn.dmg_type = MapObject::dmg_Physical;
}
if (createActQFiring(as, NULL, NULL, false, 0, &pw_to_use))
as.actions.back().state |= 64;
else
return false;
createActQFollowing(as, NULL, 1);
as.actions.back().state |= 64;
return true;
}
TableCursorKey::TableCursorKey(const KeyFileDefinition &keydef, const Tuple *keytuple, UINT fieldCount, RelationType relop) : m_keydef(keydef) {
m_fieldCount = fieldCount;
m_key.init();
m_relop = relop;
if(relop == RELOP_FALSE || relop == RELOP_TRUE) return;
if(relop == RELOP_NQ) {
m_relop = RELOP_TRUE;
m_fieldCount = 0;
return;
}
if(fieldCount == 0) {
return;
}
if(keytuple == NULL) {
throwSqlError(SQL_FATAL_ERROR,_T("TableCursorKey:No Tuple specified but field = %d"),fieldCount);
}
const Tuple &tuple = *keytuple;
if(fieldCount > tuple.size()) {
throwSqlError(SQL_FATAL_ERROR,_T("TableCursorKey:invalid fieldCount (=%d) specified. Tuple.size = %zd")
,fieldCount,tuple.size());
}
for(UINT i = 0; i < fieldCount; i++) {
DbFieldType tupleType = tuple[i].getType();
DbFieldType keyType = keydef.getFieldDef(i).getType();
if(!isCompatibleType(keyType,tupleType)) {
throwSqlError(SQL_TYPEMISMATCH,_T("Incompatible types in keydefinition(%s) and tupledefinition(%s)")
,getTypeString(keyType)
,getTypeString(tupleType));
}
const TupleField &tupField = tuple[i];
switch(getMainType(tupleType)) {
case MAINTYPE_NUMERIC :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
double d;
tupField.get(d);
if(putField(i,d)) return;
break;
}
case MAINTYPE_STRING :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
String str;
tupField.get(str);
switch(getMainType(keyType)) {
case MAINTYPE_STRING:
if(putField(i,str)) return;
break;
case MAINTYPE_VARCHAR:
{ varchar vch(str.cstr());
if(putField(i,vch)) return;
}
}
}
break;
case MAINTYPE_VARCHAR :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
varchar vch;
tupField.get(vch);
switch(getMainType(keyType)) {
case MAINTYPE_STRING:
{ String str((TCHAR*)vch.data());
if(putField(i,str)) return;
break;
}
case MAINTYPE_VARCHAR:
if(putField(i,vch)) return;
break;
}
}
break;
case MAINTYPE_DATE :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
Date d;
tupField.get(d);
keydef.put(m_key, i, d);
}
break;
case MAINTYPE_TIME :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
Time d;
tupField.get(d);
keydef.put(m_key, i, d);
}
break;
case MAINTYPE_TIMESTAMP:
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
Timestamp d;
tupField.get(d);
keydef.put(m_key, i, d);
}
break;
default:
throwSqlError(SQL_FATAL_ERROR,_T("TableCursorKey:Invalid DbMainType :%d")
,getMainType(tupleType));
break;
}
}
}
DbMainType SqlCompiler::checkValueExpressionMainType(const SyntaxNode *expr) {
DbMainType m1,m2,m3;
int i;
switch(expr->token()) {
case MULT :
case DIVOP :
case MODOP :
case EXPO :
m1 = checkValueExpressionMainType(expr->child(0));
m2 = checkValueExpressionMainType(expr->child(1));
if(m1 != MAINTYPE_NUMERIC && m1 != MAINTYPE_VOID)
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(m2 != MAINTYPE_NUMERIC && m2 != MAINTYPE_VOID)
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case PLUS :
switch(checkValueExpressionMainType(expr->child(0))) {
case MAINTYPE_NUMERIC:
m2 = checkValueExpressionMainType(expr->child(1));
if(m2 != MAINTYPE_NUMERIC && m2 != MAINTYPE_VOID)
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_DATE :
switch(checkValueExpressionMainType(expr->child(1))) {
case MAINTYPE_NUMERIC:
return MAINTYPE_DATE;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_DATE;
case MAINTYPE_DATE :
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_DATE;
case MAINTYPE_VOID :
return MAINTYPE_VOID;
}
break;
case MAINTYPE_VOID:
m2 = checkValueExpressionMainType(expr->child(1));
if(m2 != MAINTYPE_NUMERIC && m2 != MAINTYPE_VOID)
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_VOID;
}
break;
case MINUS :
if(expr->childCount() < 2) {
switch(checkValueExpressionMainType(expr->child(0))) {
case MAINTYPE_NUMERIC:
return MAINTYPE_NUMERIC;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_DATE :
syntaxError(expr,SQL_INVALID_EXPR_TYPE,_T("Unary minus not allowed on Date"));
return MAINTYPE_DATE;
case MAINTYPE_VOID :
return MAINTYPE_VOID;
}
}
else {
switch(checkValueExpressionMainType(expr->child(0))) {
case MAINTYPE_NUMERIC:
if(checkValueExpressionMainType(expr->child(1)) != MAINTYPE_NUMERIC)
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_DATE :
switch(checkValueExpressionMainType(expr->child(1))) {
case MAINTYPE_NUMERIC:
return MAINTYPE_DATE;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_DATE;
case MAINTYPE_DATE :
return MAINTYPE_NUMERIC;
case MAINTYPE_VOID :
return MAINTYPE_VOID;
}
break;
case MAINTYPE_VOID:
return MAINTYPE_VOID;
}
}
break;
case SUBSTRING:
m1 = checkValueExpressionMainType(expr->child(0));
m2 = checkValueExpressionMainType(expr->child(1));
m3 = checkValueExpressionMainType(expr->child(2));
if(!isCompatibleType(m1,MAINTYPE_STRING))
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(!isCompatibleType(m2,MAINTYPE_NUMERIC))
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(!isCompatibleType(m3,MAINTYPE_NUMERIC))
syntaxError(expr->child(2),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_STRING;
case CONCAT:
m1 = checkValueExpressionMainType(expr->child(0));
m2 = checkValueExpressionMainType(expr->child(1));
if(!isCompatibleType(m1,MAINTYPE_STRING))
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(!isCompatibleType(m2,MAINTYPE_STRING))
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_STRING;
case TYPEDATE:
for(i = 0; i < 3; i++) {
m1 = checkValueExpressionMainType(expr->child(i));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(i),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
}
return MAINTYPE_DATE;
case TYPETIME:
for(i = 0; i < 3; i++) {
m1 = checkValueExpressionMainType(expr->child(i));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(i),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
}
return MAINTYPE_TIME;
case TYPETIMESTAMP:
for(i = 0; i < 6; i++) {
m1 = checkValueExpressionMainType(expr->child(i));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(i),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
}
return MAINTYPE_TIMESTAMP;
case COUNT :
if(expr->child(0)->token() == STAR)
return MAINTYPE_NUMERIC;
else
checkValueExpressionMainType(expr->child(0)->child(0));
return MAINTYPE_NUMERIC;
case MIN :
case MAX :
return checkValueExpressionMainType(expr->child(2));
case SUM :
m1 = checkValueExpressionMainType(expr->child(2));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case NAME :
case DOT :
return MAINTYPE_NUMERIC;
case NUMBER :
return MAINTYPE_NUMERIC;
case STRING :
return MAINTYPE_STRING;
case DATECONST :
return MAINTYPE_DATE;
case TIMECONST :
return MAINTYPE_TIME;
case TIMESTAMPCONST :
return MAINTYPE_TIMESTAMP;
case HOSTVAR :
return getMainType(m_bndstmt.m_inHost[expr->getHostVarIndex()].getType());
case NULLVAL :
return MAINTYPE_VOID;
case CURRENTDATE :
return MAINTYPE_DATE;
case CURRENTTIME :
return MAINTYPE_TIME;
case CURRENTTIMESTAMP:
return MAINTYPE_TIMESTAMP;
case CAST :
{ checkValueExpressionMainType(expr->child(0));
CastParameter p = genCastParameter(expr->child(1));
return getMainType(p.getType());
}
default :
stopcomp(expr);
}
return MAINTYPE_VOID;
}
