void TSConstructObject::Build(Lexer::TTokenPos* source, std::vector<TExpressionResult>& params_result, std::vector<TSOperation*>& params, std::vector<TFormalParameter>& params_formals, TGlobalBuildContext build_context)
{
TSMethod* constructor = NULL;
if (params_result.size() > 0)
{
std::vector<TSMethod*> constructors;
object_type->GetCopyConstructors(constructors);
constructor = FindMethod(source, constructors, params_result);
if (constructor == NULL)
source->Error(" оструктора с такими парметрами не существует!");
}
else
{
constructor = object_type->GetDefConstr();
}
TSMethod* destructor = object_type->GetDestructor();
if (destructor != NULL)
{
ValidateAccess(source, owner, destructor);
}
if (constructor != NULL)
{
constructor_call.reset(new TSExpression_TMethodCall(TSExpression_TMethodCall::ObjectConstructor));
constructor_call->Build(params, constructor);
ValidateAccess(source, owner, constructor);
}
}
void Visit(SyntaxApi::IOperations::IUnaryOp* operation_node)
{
std::vector<TSOperation*> param_expressions;
TSOperation *left;
left = VisitNode(operation_node->GetLeft());
param_expressions.push_back(left);
std::vector<TExpressionResult> param;
param.resize(1);
param[0] = left->GetFormalParameter();
SemanticApi::ISMethod *unary_operator = nullptr;
if (param[0].GetClass() == nullptr)
syntax_node->Error("К данному операнду нельзя применить унарный оператор (нужен тип отличающийся от void)!");
std::vector<SemanticApi::ISMethod*> operators;
param[0].GetClass()->GetOperators(operators, operation_node->GetOp());
unary_operator = FindMethod(syntax_node, operators, param);
if (unary_operator != nullptr)
{
ValidateAccess(syntax_node, owner, unary_operator);
TSExpression_TMethodCall* method_call = new TSExpression_TMethodCall(SemanticApi::TMethodCallType::Operator);
method_call->Build(param_expressions, dynamic_cast<TSMethod*>(unary_operator));
Return(method_call);
}
else
syntax_node->Error("Унарного оператора для данного типа не существует!");
}
CValue CValue::Method(CString csName,CValue **aParams)
{
GET_THIS
int iName=FindMethod(csName);
if(iName>=0)
return pThis->Method(iName,aParams);
SetError(CString("Значение не представляет агрегатный объект (")+GetTypeString()+"."+csName+")");
return *this;
}
void Visit(SyntaxApi::IOperations::ICallParamsOp* operation_node)
{
TSOperation *left;
left = VisitNode(operation_node->GetLeft());
TExpressionResult left_result = left->GetFormalParameter();
std::vector<TExpressionResult> params_result;
std::vector<TSOperation*> param_expressions;
std::vector<SemanticApi::TFormalParameter> params_formals;
auto param = operation_node->GetParam();
for (size_t i = 0; i < param.size(); i++)
{
TSOperation* return_new_operation = VisitNode(param[i]);
param_expressions.push_back(return_new_operation);
params_result.push_back(return_new_operation->GetFormalParameter());
params_formals.push_back(SemanticApi::TFormalParameter(params_result.back().GetClass(), params_result.back().IsRef()));
}
if (left_result.IsMethods())
{
//вызов метода
if (operation_node->IsBracket())
assert(false);//при вызове метода используются круглые скобки
SemanticApi::ISMethod* invoke = nullptr;
SemanticApi::ISMethod* method = FindMethod(syntax_node, left_result.GetMethods(), params_result);
if (method != nullptr)
{
ValidateAccess(syntax_node, owner, method);
invoke = method;
}
else
syntax_node->Error("Метода с такими параметрами не существует");
TSExpression_TMethodCall* method_call = new TSExpression_TMethodCall(SemanticApi::TMethodCallType::Method);
method_call->Build(param_expressions, dynamic_cast<TSMethod*>(invoke));
method_call->left.reset(left);
//method_call->construct_temp_object->Build()
Return(method_call);
}
else if (left_result.IsType())
{
//if(left_result.GetType()->GetType()==TYPE_ENUM)
// Error("Для перечислений нельзя использовать оператор вызова параметров!");
int conv_need = -1;
std::vector<TSMethod*> constructors;
TSClass* constr_class = dynamic_cast<TSClass*>(left_result.GetType());
auto construct_object = new TSConstructObject(owner, method, parent->GetParentStatements(), constr_class);
construct_object->Build(operation_node->GetOperationSource(), params_result, param_expressions, params_formals, build_context);
TSExpression_TCreateTempObject* create_temp_obj = new TSExpression_TCreateTempObject(
(TSExpression_TypeDecl*)left,
construct_object
);
Return(create_temp_obj);
}
else
//иначе вызов оператора () или []
{
//т.к. все операторы статические - первым параметром передаем ссылку на объект
param_expressions.insert(param_expressions.begin(), left);
params_result.insert(params_result.begin(), left_result);
left = nullptr;
SemanticApi::ISMethod* invoke = nullptr;
std::vector<SemanticApi::ISMethod*> operators;
left_result.GetClass()->GetOperators(operators, operation_node->IsBracket() ? (Lexer::TOperator::GetArrayElement) : (Lexer::TOperator::ParamsCall));
SemanticApi::ISMethod* method = FindMethod(syntax_node, operators, params_result);
if (method != nullptr)
{
ValidateAccess(syntax_node, owner, method);
invoke = method;
}
else
syntax_node->Error("Оператора с такими параметрами не существует!");
TSExpression_TMethodCall* method_call = new TSExpression_TMethodCall(SemanticApi::TMethodCallType::Operator);
method_call->Build(param_expressions, dynamic_cast<TSMethod*>(invoke));
Return(method_call);
}
}
void CPipeServer::Start(void)
{
BYTE command;
while (TRUE)
{
CreatePipeandWaitForconnect();
try
{
while (TRUE)
{
command=ReadByte();
switch(command)
{
case MONOCMD_INITMONO:
InitMono();
break;
case MONOCMD_OBJECT_GETCLASS:
Object_GetClass();
break;
case MONOCMD_ENUMDOMAINS:
EnumDomains();
break;
case MONOCMD_SETCURRENTDOMAIN:
SetCurrentDomain();
break;
case MONOCMD_ENUMASSEMBLIES:
EnumAssemblies();
break;
case MONOCMD_GETIMAGEFROMASSEMBLY:
GetImageFromAssembly();
break;
case MONOCMD_GETIMAGENAME:
GetImageName();
break;
case MONOCMD_ENUMCLASSESINIMAGE:
EnumClassesInImage();
break;
case MONOCMD_ENUMFIELDSINCLASS:
EnumFieldsInClass();
break;
case MONOCMD_ENUMMETHODSINCLASS:
EnumMethodsInClass();
break;
case MONOCMD_COMPILEMETHOD:
CompileMethod();
break;
case MONOCMD_GETMETHODHEADER:
GetMethodHeader();
break;
case MONOCMD_GETMETHODHEADER_CODE:
GetILCode();
break;
case MONOCMD_LOOKUPRVA:
RvaMap();
break;
case MONOCMD_GETJITINFO:
GetJitInfo();
break;
case MONOCMD_FINDCLASS:
FindClass();
break;
case MONOCMD_FINDMETHOD:
FindMethod();
break;
case MONOCMD_GETMETHODNAME:
GetMethodName();
break;
case MONOCMD_GETMETHODCLASS:
GetMethodClass();
break;
case MONOCMD_GETCLASSNAME:
GetKlassName();
break;
case MONOCMD_GETCLASSNAMESPACE:
GetClassNamespace();
break;
case MONOCMD_FREEMETHOD:
FreeMethod();
break;
case MONOCMD_TERMINATE:
return;
case MONOCMD_DISASSEMBLE:
DisassembleMethod();
break;
case MONOCMD_GETMETHODSIGNATURE:
GetMethodSignature();
break;
case MONOCMD_GETPARENTCLASS:
GetParentClass();
break;
case MONOCMD_GETSTATICFIELDADDRESSFROMCLASS:
GetStaticFieldAddressFromClass();
break;
}
}
}
catch (char *e)
{
//Pipe error, or something else that wasn't caught. Exit the connection and start over
OutputDebugStringA("Pipe error:\n");
OutputDebugStringA(e);
if (attached)
{
mono_thread_detach(mono_selfthread);
attached=FALSE;
}
}
catch (...)
{
OutputDebugStringA("Unexpected pipe error\n");
if (attached)
{
mono_thread_detach(mono_selfthread);
attached=FALSE;
}
}
}
}
