From 19d33139fc2c619e19e073d0164d880c7f85a55c Mon Sep 17 00:00:00 2001 From: Tomasz Sowa Date: Wed, 15 Jan 2025 17:17:34 +0100 Subject: [PATCH] WIP: add a Val struct as an input/output when calling a function --- src/generator.h | 149 ++++++++++++++++++++++++++++++------------------ src/val.cpp | 49 +++++++++++++++- src/val.h | 16 +++++- 3 files changed, 155 insertions(+), 59 deletions(-) diff --git a/src/generator.h b/src/generator.h index ff7ba12..fbb0bad 100644 --- a/src/generator.h +++ b/src/generator.h @@ -396,15 +396,14 @@ private: bool CallSpace(FindHelper & find_helper); #ifdef EZC_HAS_MORM_LIBRARY - bool CallModelField(FindHelper & find_helper, morm::Model & model); + //bool CallModelField(FindHelper & find_helper, morm::Model & model); bool CallModel(FindHelper & find_helper, morm::Model & model); - bool FindLastModelWrapper(FindHelper & find_helper); + bool FindLastModelWrapper(FindHelper & find_helper, bool is_for_alias); bool CallModel(FindHelper & find_helper); bool CallModelContainerWrapper(FindHelper & find_helper); #endif bool EvaluateFunctionOrMethod(pt::Stream & out_stream, Val & val, Val & result); - bool ReduceFields(FindHelper & find_helper); void CallObject(BaseObj & base_obj, int method_index, @@ -421,7 +420,7 @@ private: // const pt::Stream & in_stream); void EvaluateParameters(FindHelper & find_helper); - bool Evaluate(FindHelper & find_helper); + //bool Evaluate(FindHelper & find_helper); bool CallValue(FindHelper & find_helper); void CleanupParameters(std::vector & parameters); @@ -1591,7 +1590,7 @@ pt::Space * Generator::CallSpaceObject(FindHelper & find_helper, pt::Space * spa void Generator::CallSpaceTableForLastField(FindHelper & find_helper, pt::Space * space) { - pt::Space::TableType * table = space->get_table(); + //pt::Space::TableType * table = space->get_table(); if( is_generating_for ) { @@ -1787,6 +1786,7 @@ bool Generator::CallSpace(FindHelper & find_helper) #ifdef EZC_HAS_MORM_LIBRARY +/* bool Generator::CallModelField(FindHelper & find_helper, morm::Model & model) { bool found = false; @@ -1818,7 +1818,7 @@ bool Generator::CallModelField(FindHelper & find_helper, morm::Model & model) return found; } - +*/ bool Generator::CallModel(FindHelper & find_helper, morm::Model & model) @@ -1839,6 +1839,7 @@ bool Generator::CallModel(FindHelper & find_helper, morm::Model & model) if( find_helper.field_index + 1 == find_helper.fields.size() ) { // last field is not a model nor a models container + /* if( !CallModelField(find_helper, model) ) { if( !IsTestingFunctionExistence() ) @@ -1849,6 +1850,7 @@ bool Generator::CallModel(FindHelper & find_helper, morm::Model & model) found = false; } + */ } else { @@ -1864,7 +1866,7 @@ bool Generator::CallModel(FindHelper & find_helper, morm::Model & model) return found; } - +/* Val * Generator::FindLastModelWrapperEvaluateMiddleFunction(FindHelper & find_helper) { @@ -1937,6 +1939,8 @@ Val * Generator::FindLastModelWrapperEvalueateFunctionsRenameMe(FindHelper & fin return child_val; } +*/ + bool Generator::EvaluateFunctionOrMethod(pt::Stream & out_stream, Val & val, Val & result) @@ -1998,56 +2002,100 @@ bool Generator::EvaluateFunctionOrMethod(pt::Stream & out_stream, Val & val, Val } -// may we should return a bool value? -bool Generator::FindLastModelWrapper(FindHelper & find_helper) +// RENAMEME +bool Generator::FindLastModelWrapper(FindHelper & find_helper, bool is_for_alias) { find_helper.field_index = 0; Val res(&find_helper.out_stream); - if( !EvaluateFunctionOrMethod(find_helper.out_stream, *find_helper.currentval, res) ) - { - return false; - } - - while( find_helper.field_index < find_helper.fields.size() && - (find_helper.currentval->has_function() || find_helper.currentval->has_method() || find_helper.currentval->has_model_object()) ) + while( find_helper.field_index < find_helper.fields.size() && find_helper.currentval->has_model_object() ) { std::wstring & field = find_helper.fields[find_helper.field_index]; Val * child_val = find_helper.currentval->find_child(field); if( !child_val ) { - Val val(&find_helper.out_stream); + morm::Model * model = nullptr; - //if( find_helper.currentval->has_function() || find_helper.currentval->has_method() ) - - - if( find_helper.currentval->has_function() ) + if( find_helper.currentval->pointer ) { - child_val = FindLastModelWrapperEvaluateMiddleFunction(find_helper); - } - else - if( find_helper.currentval->has_model_object() ) - { - child_val = FindLastModelWrapperEvalueateMiddleModel(find_helper, val); - } - - if( find_helper.field_index + 1 < find_helper.fields.size() ) - { - if( child_val && child_val->has_function() ) + if( find_helper.currentval->type == Val::TYPE_MODEL ) { - child_val = FindLastModelWrapperEvalueateFunctionsRenameMe(find_helper, child_val); + model = reinterpret_cast(find_helper.currentval->pointer); + } + else + if( find_helper.currentval->type == Val::TYPE_MODEL_CONTAINER_WRAPPER ) + { + morm::ModelContainerWrapper * model_container_wrapper = reinterpret_cast(find_helper.currentval->pointer); + model = model_container_wrapper->get_model(); + // this can return null for lists/vectors in a case when the iterator is not pointing to a valid item + } + else + if( find_helper.currentval->has_function() || find_helper.currentval->has_method() ) + { + if( (find_helper.field_index + 1 < find_helper.fields.size()) || !is_for_alias ) + { + if( EvaluateFunctionOrMethod(find_helper.out_stream, *find_helper.currentval, res) ) + { + find_helper.currentval = &res; + } + else + { + // put some error? + return false; + } + } + else + { + // IMPLEMENT me for alias + find_helper.result = *find_helper.currentval; + return true; + } + } + } + + if( model ) + { + Val val = model->get_ezc_val(nullptr, field.c_str()); + + if( val.has_function() || val.has_method() ) + { + if( (find_helper.field_index + 1 < find_helper.fields.size()) || !is_for_alias ) + { + if( EvaluateFunctionOrMethod(find_helper.out_stream, val, res) ) + { + child_val = find_helper.currentval->add_child(field, res); + } + else + { + // put some error? + return false; + } + } + else + { + // IMPLEMENT me for alias + find_helper.result = val; + return true; + } + } + else + if( val.has_object() ) + { + child_val = find_helper.currentval->add_child(field, val); } } } if( !child_val ) - break; + break; //may return false; find_helper.currentval = child_val; find_helper.currentval->set_output_stream(find_helper.out_stream); find_helper.field_index += 1; } + + return true; } @@ -2107,19 +2155,6 @@ bool Generator::CallModelContainerWrapper(FindHelper & find_helper) -// give me a better name -bool Generator::ReduceFields(FindHelper & find_helper) -{ - bool reduced = true; - - #ifdef EZC_HAS_MORM_LIBRARY - reduced = FindLastModelWrapper(find_helper); - #endif - - return reduced; -} - - void Generator::CallObject(BaseObj & base_obj, int method_index, std::vector & parameters, @@ -2237,16 +2272,16 @@ void Generator::EvaluateParameters(FindHelper & find_helper) // i cos takiego bedzie wykorzystane przy aliasach // tylko tam evaluujemy od pierwszego parametru dopiero -bool Generator::Evaluate(FindHelper & find_helper) -{ - if( !Find(find_helper) ) - return false; +// bool Generator::Evaluate(FindHelper & find_helper) +// { +// if( !Find(find_helper) ) +// return false; - EvaluateParameters(find_helper); - ReduceFields(find_helper); +// EvaluateParameters(find_helper); +// FindLastModelWrapper(find_helper); - return true; -} +// return true; +// } bool Generator::CallValue(FindHelper & find_helper) @@ -2291,7 +2326,7 @@ bool Generator::CallValue(FindHelper & find_helper) // if( find_helper.currentval->has_pod_type() ) // return CallPodType(find_helper); - if( find_helper.currentval->type == Val::TYPE_SPACE_LOCAL ) + if( find_helper.currentval->type == Val::TYPE_SPACE_LOCAL || find_helper.currentval->type == Val::TYPE_INT ) { find_helper.result = *find_helper.currentval; // IMPROVEME this makes a copy return true; @@ -2341,7 +2376,7 @@ bool Generator::Call(Item::Function & item_fun, out_stream.escape_input(true); - if( !ReduceFields(find_helper) ) + if( !FindLastModelWrapper(find_helper, false) ) return false; EvaluateParameters(find_helper); diff --git a/src/val.cpp b/src/val.cpp index 1b5fac2..7a6d733 100644 --- a/src/val.cpp +++ b/src/val.cpp @@ -5,7 +5,7 @@ */ /* - * Copyright (c) 2024, Tomasz Sowa + * Copyright (c) 2024-2025, Tomasz Sowa * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -239,6 +239,8 @@ bool Val::has_function() } +#ifdef EZC_HAS_MORM_LIBRARY + bool Val::has_method() { return type == Type::TYPE_MODEL_METHOD && pointer && (model_method1 || model_method2 || model_method3); @@ -250,6 +252,8 @@ bool Val::has_model_object() return (type == Type::TYPE_MODEL || type == Type::TYPE_MODEL_CONTAINER_WRAPPER) && pointer; } +#endif + bool Val::has_pod_type() { @@ -266,6 +270,12 @@ bool Val::has_pod_type() } +// bool Val::has_space_object() +// { +// return (type == Type::TYPE_SPACE && pointer) || (type == Type::TYPE_SPACE_LOCAL && space_local.is_object()); +// } + + bool Val::to_bool() const { switch(type) @@ -980,9 +990,46 @@ void Val::serialize_to(pt::Stream & str) case TYPE_VOID: case TYPE_FUNCTION: +#ifdef EZC_HAS_MORM_LIBRARY + case TYPE_MODEL_METHOD: +#endif case TYPE_OUTPUT_STREAM: case TYPE_ITEM_BLOCK: break; + + case TYPE_CHAR: + serialize_pod_type_to(str); + break; + case TYPE_WCHAR: + serialize_pod_type_to(str); + break; + case TYPE_SHORT: + serialize_pod_type_to(str); + break; + case TYPE_INT: + serialize_pod_type_to(str); + break; + case TYPE_LONG: + serialize_pod_type_to(str); + break; + case TYPE_LONG_LONG: + serialize_pod_type_to(str); + break; + case TYPE_UNSIGNED_CHAR: + serialize_pod_type_to(str); + break; + case TYPE_UNSIGNED_SHORT: + serialize_pod_type_to(str); + break; + case TYPE_UNSIGNED_INT: + serialize_pod_type_to(str); + break; + case TYPE_UNSIGNED_LONG: + serialize_pod_type_to(str); + break; + case TYPE_UNSIGNED_LONG_LONG: + serialize_pod_type_to(str); + break; } } diff --git a/src/val.h b/src/val.h index 46f1738..60d84fd 100644 --- a/src/val.h +++ b/src/val.h @@ -79,10 +79,12 @@ public: TYPE_SPACE_LOCAL, TYPE_STREAM, TYPE_FUNCTION, - TYPE_MODEL_METHOD, TYPE_DATE, +#ifdef EZC_HAS_MORM_LIBRARY TYPE_MODEL, TYPE_MODEL_CONTAINER_WRAPPER, + TYPE_MODEL_METHOD, +#endif TYPE_SPACE, TYPE_OUTPUT_STREAM, TYPE_ITEM_BLOCK, @@ -115,9 +117,14 @@ public: bool has_object(); bool has_function(); + +#ifdef EZC_HAS_MORM_LIBRARY bool has_method(); bool has_model_object(); +#endif + bool has_pod_type(); + //bool has_space_object(); void clear(); void clear_childs(); @@ -306,6 +313,13 @@ private: void serialize_model_container_wrapper_to(pt::Stream & str); void serialize_space_to(pt::Stream & str); + template + void serialize_pod_type_to(pt::Stream & str) + { + PODType * val = reinterpret_cast(pointer); + str << *val; + } + /* * old