From 759d0031f4f9c1f04ebffa44770ed1ab62ee89dd Mon Sep 17 00:00:00 2001 From: lizdulac Date: Wed, 24 Jan 2024 11:47:46 -0500 Subject: [PATCH 01/46] Derived Expressions Curl function with correctness test --- examples/CMakeLists.txt | 17 +- source/adios2/toolkit/derived/ExprHelper.h | 7 +- source/adios2/toolkit/derived/Function.cpp | 110 ++++++++++++ source/adios2/toolkit/derived/Function.h | 6 + .../derived/TestBPDerivedCorrectness.cpp | 164 +++++++++++++++++- 5 files changed, 290 insertions(+), 14 deletions(-) diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index ad7194aacf..40b4c203e9 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -3,11 +3,12 @@ # accompanying file Copyright.txt for details. #------------------------------------------------------------------------------# -add_subdirectory(basics) -add_subdirectory(hello) -add_subdirectory(plugins) -add_subdirectory(simulations) -add_subdirectory(useCases) -if(ADIOS2_USE_Campaign) - add_subdirectory(campaign) -endif() +#add_subdirectory(basics) +add_subdirectory(derived) +#add_subdirectory(hello) +#add_subdirectory(plugins) +#add_subdirectory(simulations) +#add_subdirectory(useCases) +#if(ADIOS2_USE_Campaign) +# add_subdirectory(campaign) +#endif() diff --git a/source/adios2/toolkit/derived/ExprHelper.h b/source/adios2/toolkit/derived/ExprHelper.h index c72888f95f..38672cfec4 100644 --- a/source/adios2/toolkit/derived/ExprHelper.h +++ b/source/adios2/toolkit/derived/ExprHelper.h @@ -21,7 +21,8 @@ enum ExpressionOperator OP_ADD, OP_SQRT, OP_POW, - OP_MAGN + OP_MAGN, + OP_CURL }; struct OperatorProperty @@ -39,6 +40,7 @@ const std::map op_property = { {ExpressionOperator::OP_ADD, {"ADD", true}}, {ExpressionOperator::OP_SQRT, {"SQRT", false}}, {ExpressionOperator::OP_POW, {"POW", false}}, + {ExpressionOperator::OP_CURL, {"CURL", false}}, {ExpressionOperator::OP_MAGN, {"MAGNITUDE", false}}}; const std::map string_to_op = { @@ -49,6 +51,7 @@ const std::map string_to_op = { {"add", ExpressionOperator::OP_ADD}, {"ADD", ExpressionOperator::OP_ADD}, {"SQRT", ExpressionOperator::OP_SQRT}, {"sqrt", ExpressionOperator::OP_SQRT}, {"POW", ExpressionOperator::OP_POW}, {"^", ExpressionOperator::OP_POW}, + {"CURL", ExpressionOperator::OP_CURL}, {"curl", ExpressionOperator::OP_CURL}, {"MAGNITUDE", ExpressionOperator::OP_MAGN}, {"magnitude", ExpressionOperator::OP_MAGN}}; inline std::string get_op_name(ExpressionOperator op) { return op_property.at(op).name; } @@ -57,4 +60,4 @@ inline ExpressionOperator get_op(std::string op) { return string_to_op.at(op); } } } -#endif \ No newline at end of file +#endif diff --git a/source/adios2/toolkit/derived/Function.cpp b/source/adios2/toolkit/derived/Function.cpp index c524ac8c15..6b5f2e7a40 100644 --- a/source/adios2/toolkit/derived/Function.cpp +++ b/source/adios2/toolkit/derived/Function.cpp @@ -63,6 +63,116 @@ Dims SameDimsFunc(std::vector input) return input[0]; } +// Input Dims are the same, output is combination of all inputs +Dims AggrSameDimsFunc(std::vector input) +{ + // check that all dimenstions are the same + if (input.size() > 1) + { + bool dim_are_equal = std::equal(input.begin() + 1, input.end(), input.begin()); + if (!dim_are_equal) + helper::Throw("Derived", "Function", "AggrSameDimFunc", + "Invalid variable dimensions"); + } + // return the first dimension + Dims output = input[0]; + size_t num_dims = output.size(); + output.insert(output.begin(), num_dims); + return output; +} + +/* + * Linear Interpolation - average difference around point "index" + * can be used to approximate derivatives + * + * Input: + * data - assumed to be uniform/densely populated + * index - index of point of interest + * count - number of elements in data + * stride - how to access neighbours + */ +template +T linear_interp (T* data, size_t index, size_t count, size_t stride) +{ + size_t ind1 = index - stride; + size_t ind2 = index + stride; + bool boundary = false; + if (index < stride) + { + ind1 = index; + boundary = true; + } + if (count - index <= stride) + { + ind2 = index; + boundary = true; + } + // If stride is out of bounds in both directions, ind1 = ind2 = index + // return 0 + + return (data[ind2] - data[ind1]) / (boundary? 1: 2); +} + +/* + * Input: 3D vector field F(x,y,z)= {F1(x,y,z), F2(x,y,z), F3(x,y,z)} + * + * inputData - (3) components of 3D vector field + * margin - how many elements to each size will be used in approximating partial derivatives + * center - include point (x,y,z) in approximating of partial derivative at that point + * + * Computation: + * curl(F(x,y,z)) = (partial(F3,y) - partial(F2,z))i + * + (partial(F1,z) - partial(F3,x))j + * + (partial(F2,x) - partial(F1,y))k + * + * boundaries are calculated only with data in block + * (ex: partial derivatives in x direction at point (0,0,0) + * only use data from (1,0,0), etc ) + * + * Return: + * (3) components of curl + */ +/* +template +std::vector computecurl3D (const std::vector inputData, size_t margin, bool center, std::function pdcomp) +*/ +DerivedData Curl3DFunc(const std::vector inputData, DataType type) +{ + // ToDo - verify how to navigate over the inputData spaces + size_t xcount = inputData[0].Count[0]; + size_t ycount = inputData[0].Count[1]; + size_t zcount = inputData[0].Count[2]; + size_t dataSize = xcount * ycount * zcount; + size_t xstride = ycount * zcount; + size_t ystride = zcount; + size_t zstride = 1; + + DerivedData curl; + // ToDo - template type + float* data = (float*)malloc(dataSize * sizeof(float) * 3); + curl.Start = inputData[0].Start; + curl.Start.insert(curl.Start.begin(), 0); + curl.Count = inputData[0].Count; + curl.Count.insert(curl.Count.begin(), 3); + + for (size_t i = 0; i < xcount; ++i) + { + for (size_t j = 0; j < ycount; ++j) + { + for (size_t k = 0; k < zcount; ++k) + { + size_t index = (i * xstride) + (j * ystride) + (k * zstride); + data[3 * index] = linear_interp((float*)inputData[2].Data, index, dataSize, ystride) - linear_interp((float*)inputData[1].Data, index, dataSize, zstride); + data[3 * index + 1] = linear_interp((float*)inputData[0].Data, index, dataSize, zstride) - linear_interp((float*)inputData[2].Data, index, dataSize, xstride); + data[3 * index + 2] = linear_interp((float*)inputData[1].Data, index, dataSize, xstride) - linear_interp((float*)inputData[0].Data, index, dataSize, ystride); + } + } + } + + curl.Data = data; + return curl; +} + #define declare_template_instantiation(T) \ T *ApplyOneToOne(std::vector, size_t, std::function); diff --git a/source/adios2/toolkit/derived/Function.h b/source/adios2/toolkit/derived/Function.h index 5dfa5aba97..4969a69186 100644 --- a/source/adios2/toolkit/derived/Function.h +++ b/source/adios2/toolkit/derived/Function.h @@ -26,11 +26,17 @@ struct OperatorFunctions DerivedData AddFunc(std::vector input, DataType type); DerivedData MagnitudeFunc(std::vector input, DataType type); +DerivedData Curl3DFunc(std::vector input, DataType type); + +template +T linear_interp (T* data, size_t index, size_t count, size_t stride = 1); Dims SameDimsFunc(std::vector input); +Dims AggrSameDimsFunc(std::vector input); const std::map OpFunctions = { {adios2::detail::ExpressionOperator::OP_ADD, {AddFunc, SameDimsFunc}}, + {adios2::detail::ExpressionOperator::OP_CURL, {Curl3DFunc, AggrSameDimsFunc}}, {adios2::detail::ExpressionOperator::OP_MAGN, {MagnitudeFunc, SameDimsFunc}}}; template diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index 002015b843..baf74eeae4 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -36,13 +36,9 @@ TEST(DerivedCorrectness, AddCorrectnessTest) std::vector varname = {"sim1/Ux", "sim1/Uy", "sim1/Uz"}; std::string derivedname = "derived/addU"; - std::cout << "Define Variable " << varname[0] << std::endl; auto Ux = bpOut.DefineVariable(varname[0], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - std::cout << "Define Variable " << varname[1] << std::endl; auto Uy = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - std::cout << "Define Variable " << varname[2] << std::endl; auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - std::cout << "Define Derived Variable " << derivedname << std::endl; // clang-format off auto addU = bpOut.DefineDerivedVariable(derivedname, "x:" + varname[0] + " \n" @@ -172,6 +168,166 @@ TEST(DerivedCorrectness, MagCorrectnessTest) bpFileReader.Close(); } +/* + * Linear Interpolation - average difference around point "index" + * + */ +// T linear_interp (T* data, size_t index, size_t count, size_t stride, size_t margin, bool center) +float linear_interp (std::vector data, size_t index, size_t count, size_t stride) +{ + size_t ind1 = index - stride; + size_t ind2 = index + stride; + bool boundary = false; + if (index < stride) + { + ind1 = index; + boundary = true; + } + if (count - index <= stride) + { + ind2 = index; + boundary = true; + } + // If stride is out of bounds in both directions, ind1 = ind2 = index + // return 0 + return (data[ind2] - data[ind1]) / (boundary? 1: 2); +} + +/* + * Input: 3D vector field F(x,y,z)= {F1(x,y,z), F2(x,y,z), F3(x,y,z)} + * + * inputData - (3) components of 3D vector field + * margin - how many elements to each size will be used in approximating partial derivatives + * center - include point (x,y,z) in approximating of partial derivative at that point + * + * Computation: + * curl(F(x,y,z)) = (partial(F3,y) - partial(F2,z))i + * + (partial(F1,z) - partial(F3,x))j + * + (partial(F2,x) - partial(F1,y))k + * + * boundaries are calculated only with data in block + * (ex: partial derivatives in x direction at point (0,0,0) + * only use data from (1,0,0), etc ) + * + * Return: + * (3) components of curl + */ +//std::vector computecurl3D +//const std::vector inputData, size_t xcount, size_t ycount, size_t zcount, size_t margin, bool center, std::function pdcomp) +std::vector> computecurl3D (std::vector inputX, std::vector inputY, std::vector inputZ, size_t xcount, size_t ycount, size_t zcount) +{ + // ToDo - verify how to navigate over the inputData spaces + size_t dataSize = xcount * ycount * zcount; + size_t xstride = ycount * zcount; + size_t ystride = zcount; + size_t zstride = 1; + + std::vector curlx(dataSize); + std::vector curly(dataSize); + std::vector curlz(dataSize); + std::vector> curl = {curlx, curly, curlz}; + // std::vector curl = {(T*)malloc(xcount * ycount * zcount * sizeof(T)), (T*)malloc(xcount * ycount * zcount * sizeof(T)), (T*)malloc(xcount * ycount * zcount * sizeof(T))}; + + for (size_t i = 0; i < xcount; ++i) + { + for (size_t j = 0; j < ycount; ++j) + { + for (size_t k = 0; k < zcount; ++k) + { + size_t index = (i * xstride) + (j * ystride) + (k * zstride); + curl[0][index] = linear_interp(inputZ, index, dataSize, ystride) - linear_interp(inputY, index, dataSize, zstride); + curl[1][index] = linear_interp(inputX, index, dataSize, zstride) - linear_interp(inputZ, index, dataSize, xstride); + curl[2][index] = linear_interp(inputY, index, dataSize, xstride) - linear_interp(inputX, index, dataSize, ystride); + } + } + } + + return curl; +} + +TEST(DerivedCorrectness, CurlCorrectnessTest) +{ + const size_t Nx = 2, Ny = 3, Nz = 10; + const size_t steps = 2; + // Application variable + std::default_random_engine generator; + std::uniform_real_distribution distribution(0.0, 10.0); + + std::vector simArray1(Nx * Ny * Nz); + std::vector simArray2(Nx * Ny * Nz); + std::vector simArray3(Nx * Ny * Nz); + for (size_t i = 0; i < Nx * Ny * Nz; ++i) + { + simArray1[i] = distribution(generator); + simArray2[i] = distribution(generator); + simArray3[i] = distribution(generator); + } + + adios2::ADIOS adios; + adios2::IO bpOut = adios.DeclareIO("BPWriteExpression"); + std::vector varname = {"sim3/VX", "sim3/VY", "sim3/VZ"}; + std::string derivedname = "derived/curlV"; + + auto VX = bpOut.DefineVariable(varname[0], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); + auto VY = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); + auto VZ = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); + // clang-format off + auto curlV = bpOut.DefineDerivedVariable(derivedname, + "Vx:" + varname[0] + " \n" + "Vy:" + varname[1] + " \n" + "Vz:" + varname[2] + " \n" + "curl(Vx,Vy,Vz)", + adios2::DerivedVarType::StoreData); + // clang-format on + std::string filename = "expCurl.bp"; + adios2::Engine bpFileWriter = bpOut.Open(filename, adios2::Mode::Write); + + for (int i = 0; i < steps; i++) + { + bpFileWriter.BeginStep(); + bpFileWriter.Put(VX, simArray1.data()); + bpFileWriter.Put(VY, simArray2.data()); + bpFileWriter.Put(VZ, simArray3.data()); + bpFileWriter.EndStep(); + } + bpFileWriter.Close(); + + adios2::IO bpIn = adios.DeclareIO("BPReadCurlExpression"); + adios2::Engine bpFileReader = bpIn.Open(filename, adios2::Mode::Read); + + std::vector readVX; + std::vector readVY; + std::vector readVZ; + // TODO/DEBUG - VERIFY DATATYPE + std::vector readCurl; + + std::vector> calcCurl; + float epsilon = 0.01; + for (int i = 0; i < steps; i++) + { + bpFileReader.BeginStep(); + auto varVX = bpIn.InquireVariable(varname[0]); + auto varVY = bpIn.InquireVariable(varname[1]); + auto varVZ = bpIn.InquireVariable(varname[2]); + auto varCurl = bpIn.InquireVariable(derivedname); + + bpFileReader.Get(varVX, readVX); + bpFileReader.Get(varVY, readVY); + bpFileReader.Get(varVZ, readVZ); + bpFileReader.Get(varCurl, readCurl); + bpFileReader.EndStep(); + + calcCurl = computecurl3D (readVX, readVY, readVZ, Nx, Ny, Nz); + for (size_t ind = 0; ind < Nx * Ny * Nz; ++ind) + { + EXPECT_TRUE(fabs(calcCurl[0][ind] - readCurl[3 * ind]) < epsilon); + EXPECT_TRUE(fabs(calcCurl[1][ind] - readCurl[3 * ind + 1]) < epsilon); + EXPECT_TRUE(fabs(calcCurl[2][ind] - readCurl[3 * ind + 2]) < epsilon); + } + } + bpFileReader.Close(); +} + int main(int argc, char **argv) { int result; From 20bd7c83c7f615909784f9a0db62bc5057779b8c Mon Sep 17 00:00:00 2001 From: lizdulac Date: Fri, 26 Jan 2024 11:22:47 -0500 Subject: [PATCH 02/46] Fixing index bug for internal boundaries --- source/adios2/toolkit/derived/Function.cpp | 67 ++++--- .../derived/TestBPDerivedCorrectness.cpp | 186 +++++++++++++----- 2 files changed, 170 insertions(+), 83 deletions(-) diff --git a/source/adios2/toolkit/derived/Function.cpp b/source/adios2/toolkit/derived/Function.cpp index 6b5f2e7a40..a1c5105626 100644 --- a/source/adios2/toolkit/derived/Function.cpp +++ b/source/adios2/toolkit/derived/Function.cpp @@ -74,10 +74,9 @@ Dims AggrSameDimsFunc(std::vector input) helper::Throw("Derived", "Function", "AggrSameDimFunc", "Invalid variable dimensions"); } - // return the first dimension + // return original dimensions with added dimension of number of inputs Dims output = input[0]; - size_t num_dims = output.size(); - output.insert(output.begin(), num_dims); + output.push_back(input.size()); return output; } @@ -91,26 +90,42 @@ Dims AggrSameDimsFunc(std::vector input) * count - number of elements in data * stride - how to access neighbours */ -template -T linear_interp (T* data, size_t index, size_t count, size_t stride) +//template +float linear_interp (DerivedData input, size_t index, size_t dim) { + size_t stride = 1; + size_t range; + size_t offset; + float result; + float* data = (float*)input.Data; + + for (size_t i = 0; i < input.Count.size() - (dim + 1); ++i) + { + stride *= input.Count[input.Count.size() - (i + 1)]; + } size_t ind1 = index - stride; size_t ind2 = index + stride; - bool boundary = false; - if (index < stride) + range = stride * input.Count[dim]; + offset = index % range; + + if ((offset < stride) && (range - offset <= stride)) { - ind1 = index; - boundary = true; + return 0; } - if (count - index <= stride) + else if (offset < stride) { - ind2 = index; - boundary = true; + result = data[ind2] - data[index]; } - // If stride is out of bounds in both directions, ind1 = ind2 = index - // return 0 - - return (data[ind2] - data[ind1]) / (boundary? 1: 2); + else if (range - offset <= stride) + { + result = data[index] - data[ind1]; + } + else + { + result = (data[ind2] - data[ind1]) / 2; + } + + return result; } /* @@ -151,24 +166,16 @@ DerivedData Curl3DFunc(const std::vector inputData, DataType type) // ToDo - template type float* data = (float*)malloc(dataSize * sizeof(float) * 3); curl.Start = inputData[0].Start; - curl.Start.insert(curl.Start.begin(), 0); + curl.Start.push_back(0); curl.Count = inputData[0].Count; - curl.Count.insert(curl.Count.begin(), 3); + curl.Count.push_back(3); - for (size_t i = 0; i < xcount; ++i) + for (size_t i = 0; i < dataSize; ++i) { - for (size_t j = 0; j < ycount; ++j) - { - for (size_t k = 0; k < zcount; ++k) - { - size_t index = (i * xstride) + (j * ystride) + (k * zstride); - data[3 * index] = linear_interp((float*)inputData[2].Data, index, dataSize, ystride) - linear_interp((float*)inputData[1].Data, index, dataSize, zstride); - data[3 * index + 1] = linear_interp((float*)inputData[0].Data, index, dataSize, zstride) - linear_interp((float*)inputData[2].Data, index, dataSize, xstride); - data[3 * index + 2] = linear_interp((float*)inputData[1].Data, index, dataSize, xstride) - linear_interp((float*)inputData[0].Data, index, dataSize, ystride); - } - } + data[3 * i] = linear_interp(inputData[2], i, 1) - linear_interp(inputData[1], i, 2); + data[3 * i + 1] = linear_interp(inputData[0], i, 2) - linear_interp(inputData[2], i, 0); + data[3 * i + 2] = linear_interp(inputData[1], i, 0) - linear_interp(inputData[0], i, 1); } - curl.Data = data; return curl; } diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index baf74eeae4..db870d41b9 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -169,26 +170,26 @@ TEST(DerivedCorrectness, MagCorrectnessTest) } /* - * Linear Interpolation - average difference around point "index" + * Linear Interpolation - average difference around point "idx" * */ -// T linear_interp (T* data, size_t index, size_t count, size_t stride, size_t margin, bool center) -float linear_interp (std::vector data, size_t index, size_t count, size_t stride) +// T linear_interp (T* data, size_t idx, size_t count, size_t stride, size_t margin, bool center) +float linear_interp (std::vector data, size_t idx, size_t count, size_t stride) { - size_t ind1 = index - stride; - size_t ind2 = index + stride; + size_t ind1 = idx - stride; + size_t ind2 = idx + stride; bool boundary = false; - if (index < stride) + if (idx < stride) { - ind1 = index; + ind1 = idx; boundary = true; } - if (count - index <= stride) + if (count - idx <= stride) { - ind2 = index; + ind2 = idx; boundary = true; } - // If stride is out of bounds in both directions, ind1 = ind2 = index + // If stride is out of bounds in both directions, ind1 = ind2 = idx // return 0 return (data[ind2] - data[ind1]) / (boundary? 1: 2); } @@ -234,10 +235,10 @@ std::vector> computecurl3D (std::vector inputX, std::v { for (size_t k = 0; k < zcount; ++k) { - size_t index = (i * xstride) + (j * ystride) + (k * zstride); - curl[0][index] = linear_interp(inputZ, index, dataSize, ystride) - linear_interp(inputY, index, dataSize, zstride); - curl[1][index] = linear_interp(inputX, index, dataSize, zstride) - linear_interp(inputZ, index, dataSize, xstride); - curl[2][index] = linear_interp(inputY, index, dataSize, xstride) - linear_interp(inputX, index, dataSize, ystride); + size_t idx = (i * xstride) + (j * ystride) + (k * zstride); + curl[0][idx] = linear_interp(inputZ, idx, dataSize, ystride) - linear_interp(inputY, idx, dataSize, zstride); + curl[1][idx] = linear_interp(inputX, idx, dataSize, zstride) - linear_interp(inputZ, idx, dataSize, xstride); + curl[2][idx] = linear_interp(inputY, idx, dataSize, xstride) - linear_interp(inputX, idx, dataSize, ystride); } } } @@ -247,20 +248,36 @@ std::vector> computecurl3D (std::vector inputX, std::v TEST(DerivedCorrectness, CurlCorrectnessTest) { - const size_t Nx = 2, Ny = 3, Nz = 10; - const size_t steps = 2; - // Application variable - std::default_random_engine generator; - std::uniform_real_distribution distribution(0.0, 10.0); + const size_t Nx = 5, Ny = 7, Nz = 11; + // Application variable std::vector simArray1(Nx * Ny * Nz); std::vector simArray2(Nx * Ny * Nz); std::vector simArray3(Nx * Ny * Nz); - for (size_t i = 0; i < Nx * Ny * Nz; ++i) + for (float x = 0; x < Nx; ++x) { - simArray1[i] = distribution(generator); - simArray2[i] = distribution(generator); - simArray3[i] = distribution(generator); + for (float y = 0; y < Ny; ++y) + { + for (float z = 0; z < Nz; ++z) + { + size_t idx = (x * Ny * Nz) + (y * Nz) + z; + /**/// Linear curl example + simArray1[idx] = (6 * x * y) + (7 * z); + simArray2[idx] = (4 * x * z) + pow(y, 2); + simArray3[idx] = sqrt(z) + (2 * x * y); + /* */ + /*/// Less linear example + simArray1[idx] = sin(z); + simArray2[idx] = 4 * x; + simArray3[idx] = pow(y, 2) * cos(x); + */ + /*/// Nonlinear example + simArray1[idx] = exp(2 * y) * sin(x); + simArray2[idx] = sqrt(z) * cos(x); + simArray3[idx] = pow(x, 2) * sin(y) + (6 * z); + */ + } + } } adios2::ADIOS adios; @@ -282,14 +299,11 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) std::string filename = "expCurl.bp"; adios2::Engine bpFileWriter = bpOut.Open(filename, adios2::Mode::Write); - for (int i = 0; i < steps; i++) - { - bpFileWriter.BeginStep(); - bpFileWriter.Put(VX, simArray1.data()); - bpFileWriter.Put(VY, simArray2.data()); - bpFileWriter.Put(VZ, simArray3.data()); - bpFileWriter.EndStep(); - } + bpFileWriter.BeginStep(); + bpFileWriter.Put(VX, simArray1.data()); + bpFileWriter.Put(VY, simArray2.data()); + bpFileWriter.Put(VZ, simArray3.data()); + bpFileWriter.EndStep(); bpFileWriter.Close(); adios2::IO bpIn = adios.DeclareIO("BPReadCurlExpression"); @@ -302,30 +316,96 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) std::vector readCurl; std::vector> calcCurl; - float epsilon = 0.01; - for (int i = 0; i < steps; i++) - { - bpFileReader.BeginStep(); - auto varVX = bpIn.InquireVariable(varname[0]); - auto varVY = bpIn.InquireVariable(varname[1]); - auto varVZ = bpIn.InquireVariable(varname[2]); - auto varCurl = bpIn.InquireVariable(derivedname); - - bpFileReader.Get(varVX, readVX); - bpFileReader.Get(varVY, readVY); - bpFileReader.Get(varVZ, readVZ); - bpFileReader.Get(varCurl, readCurl); - bpFileReader.EndStep(); - - calcCurl = computecurl3D (readVX, readVY, readVZ, Nx, Ny, Nz); - for (size_t ind = 0; ind < Nx * Ny * Nz; ++ind) - { - EXPECT_TRUE(fabs(calcCurl[0][ind] - readCurl[3 * ind]) < epsilon); - EXPECT_TRUE(fabs(calcCurl[1][ind] - readCurl[3 * ind + 1]) < epsilon); - EXPECT_TRUE(fabs(calcCurl[2][ind] - readCurl[3 * ind + 2]) < epsilon); - } + double sum_x = 0; + double sum_y = 0; + double sum_z = 0; + // keep count of how many data points were ignored + // error values will be skipped for data values of infinity + size_t inf_x = 0; + size_t inf_y = 0; + size_t inf_z = 0; + bpFileReader.BeginStep(); + auto varVX = bpIn.InquireVariable(varname[0]); + auto varVY = bpIn.InquireVariable(varname[1]); + auto varVZ = bpIn.InquireVariable(varname[2]); + auto varCurl = bpIn.InquireVariable(derivedname); + + bpFileReader.Get(varVX, readVX); + bpFileReader.Get(varVY, readVY); + bpFileReader.Get(varVZ, readVZ); + bpFileReader.Get(varCurl, readCurl); + bpFileReader.EndStep(); + + float curl_x, curl_y, curl_z; + float err_x, err_y, err_z; + for (float x = 0; x < Nx; ++x) + { + for (float y = 0; y < Ny; ++y) + { + for (float z = 0; z < Nz; ++z) + { + size_t idx = (x * Ny * Nz) + (y * Nz) + z; + /**/// Linear example + curl_x = -(2 * x); + curl_y = 7 - (2 * y); + curl_z = (4 * z) - (6 * x); + /* */ + /*/// Less linear + curl_x = 2 * y * cos(x); + curl_y = cos(z) + (pow(y, 2) * sin(x)); + curl_z = 4; + */ + /*/// Nonlinear example + curl_x = pow(x, 2) * cos(y) - (cos(x) / (2 * sqrt(z))); + curl_y = -2 * x * sin(y); + curl_z = -sqrt(z) * sin(x) - (2 * exp(2 * y) * sin(x)); + */ + if (fabs(curl_x) == std::numeric_limits::infinity()) + { + err_x = 0; + ++inf_x; + } + else + { + err_x = fabs(curl_x - readCurl[3 * idx]) / (1 + fabs(curl_x)); + } + if (fabs(curl_y) == std::numeric_limits::infinity()) + { + err_y = 0; + ++inf_y; + } + else + { + err_y = fabs(curl_y - readCurl[3 * idx + 1]) / (1 + fabs(curl_y)); + } + if (fabs(curl_z) == std::numeric_limits::infinity()) + { + err_z = 0; + ++inf_z; + } + else + { + err_z = fabs(curl_z - readCurl[3 * idx + 2]) / (1 + fabs(curl_z)); + } + sum_x += err_x; + sum_y += err_y; + sum_z += err_z; + std::cout << "Test curl at (" << x << ", " << y << ", " << z << ")\n"; + std::cout << "\tExpected: <" << curl_x << ", " << curl_y << ", " << curl_z << ">\n"; + std::cout << "\t Read: <" << readCurl[3 * idx] << ", " << readCurl[3 * idx + 1] << ", " << readCurl[3 * idx + 2] << ">" << std::endl; + std::cout << "\tRelative error: " << err_x << ", " << err_y << ", " << err_z << std::endl; + } + } } bpFileReader.Close(); + std::cout << "Finished reading curl. Ave rel error: " << (sum_x + sum_y + sum_z)/ ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)) << std::endl; + std::cout << "\tave in x: " << (sum_x / ((Nx * Ny * Nz) - inf_x)) << std::endl; + std::cout << "\tave in y: " << (sum_y / ((Nx * Ny * Nz) - inf_y)) << std::endl; + std::cout << "\tave in z: " << (sum_z / ((Nx * Ny * Nz) - inf_z)) << std::endl; + EXPECT_LT((sum_x + sum_y + sum_z) / ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)), 0.5); + EXPECT_LT(sum_x / ((Nx * Ny * Nz) - inf_x), 0.7); + EXPECT_LT(sum_y / ((Nx * Ny * Nz) - inf_y), 0.7); + EXPECT_LT(sum_z / ((Nx * Ny * Nz) - inf_z), 0.7); } int main(int argc, char **argv) From a73f535280097b7cfd642c8f05d6d4aee47ce13c Mon Sep 17 00:00:00 2001 From: lizdulac Date: Fri, 26 Jan 2024 16:20:24 -0500 Subject: [PATCH 03/46] Curl Correctness Test Cleanup --- .../derived/TestBPDerivedCorrectness.cpp | 52 ++++++++++++------- 1 file changed, 33 insertions(+), 19 deletions(-) diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index db870d41b9..7611f26216 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -249,6 +249,7 @@ std::vector> computecurl3D (std::vector inputX, std::v TEST(DerivedCorrectness, CurlCorrectnessTest) { const size_t Nx = 5, Ny = 7, Nz = 11; + float error_limit = 0.000001; // Application variable std::vector simArray1(Nx * Ny * Nz); @@ -261,19 +262,18 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) for (float z = 0; z < Nz; ++z) { size_t idx = (x * Ny * Nz) + (y * Nz) + z; - /**/// Linear curl example + // Linear curl example simArray1[idx] = (6 * x * y) + (7 * z); simArray2[idx] = (4 * x * z) + pow(y, 2); simArray3[idx] = sqrt(z) + (2 * x * y); - /* */ - /*/// Less linear example + /* Less linear example simArray1[idx] = sin(z); simArray2[idx] = 4 * x; simArray3[idx] = pow(y, 2) * cos(x); */ - /*/// Nonlinear example + /* Nonlinear example simArray1[idx] = exp(2 * y) * sin(x); - simArray2[idx] = sqrt(z) * cos(x); + simArray2[idx] = sqrt(z + 1) * cos(x); simArray3[idx] = pow(x, 2) * sin(y) + (6 * z); */ } @@ -345,48 +345,59 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) for (float z = 0; z < Nz; ++z) { size_t idx = (x * Ny * Nz) + (y * Nz) + z; - /**/// Linear example + // Linear example curl_x = -(2 * x); curl_y = 7 - (2 * y); curl_z = (4 * z) - (6 * x); - /* */ - /*/// Less linear + /* Less linear curl_x = 2 * y * cos(x); curl_y = cos(z) + (pow(y, 2) * sin(x)); curl_z = 4; */ - /*/// Nonlinear example - curl_x = pow(x, 2) * cos(y) - (cos(x) / (2 * sqrt(z))); - curl_y = -2 * x * sin(y); - curl_z = -sqrt(z) * sin(x) - (2 * exp(2 * y) * sin(x)); + /* Nonlinear example + curl_x = pow(x, 2) * cos(y) - (cos(x) / (2 * sqrt(z + 1))); + curl_y = -2 * x * sin(y); + curl_z = -sqrt(z + 1) * sin(x) - (2 * exp(2 * y) * sin(x)); */ if (fabs(curl_x) == std::numeric_limits::infinity()) { err_x = 0; ++inf_x; } + else if (fabs(curl_x) < 1) + { + err_x = fabs(curl_x - readCurl[3 * idx]) / (1 + fabs(curl_x)); + } else { - err_x = fabs(curl_x - readCurl[3 * idx]) / (1 + fabs(curl_x)); + err_x = fabs(curl_x - readCurl[3 * idx]) / fabs(curl_x); } if (fabs(curl_y) == std::numeric_limits::infinity()) { err_y = 0; ++inf_y; } - else + else if (fabs(curl_y) < 1) { err_y = fabs(curl_y - readCurl[3 * idx + 1]) / (1 + fabs(curl_y)); } + else + { + err_y = fabs(curl_y - readCurl[3 * idx + 1]) / fabs(curl_y); + } if (fabs(curl_z) == std::numeric_limits::infinity()) { err_z = 0; ++inf_z; } - else + else if (fabs(curl_z) < 1) { err_z = fabs(curl_z - readCurl[3 * idx + 2]) / (1 + fabs(curl_z)); } + else + { + err_z = fabs(curl_z - readCurl[3 * idx + 2]) / fabs(curl_z); + } sum_x += err_x; sum_y += err_y; sum_z += err_z; @@ -400,12 +411,15 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) bpFileReader.Close(); std::cout << "Finished reading curl. Ave rel error: " << (sum_x + sum_y + sum_z)/ ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)) << std::endl; std::cout << "\tave in x: " << (sum_x / ((Nx * Ny * Nz) - inf_x)) << std::endl; + std::cout << "\tskipped x values (infinity): " << inf_x << std::endl; std::cout << "\tave in y: " << (sum_y / ((Nx * Ny * Nz) - inf_y)) << std::endl; + std::cout << "\tskipped y values (infinity): " << inf_y << std::endl; std::cout << "\tave in z: " << (sum_z / ((Nx * Ny * Nz) - inf_z)) << std::endl; - EXPECT_LT((sum_x + sum_y + sum_z) / ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)), 0.5); - EXPECT_LT(sum_x / ((Nx * Ny * Nz) - inf_x), 0.7); - EXPECT_LT(sum_y / ((Nx * Ny * Nz) - inf_y), 0.7); - EXPECT_LT(sum_z / ((Nx * Ny * Nz) - inf_z), 0.7); + std::cout << "\tskipped z values (infinity): " << inf_z << std::endl; + EXPECT_LT((sum_x + sum_y + sum_z) / ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)), error_limit); + EXPECT_LT(sum_x / ((Nx * Ny * Nz) - inf_x), error_limit); + EXPECT_LT(sum_y / ((Nx * Ny * Nz) - inf_y), error_limit); + EXPECT_LT(sum_z / ((Nx * Ny * Nz) - inf_z), error_limit); } int main(int argc, char **argv) From dd153a4f1035f5492d03c30f69d28d89a7ff12c4 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Tue, 6 Feb 2024 13:58:46 -0500 Subject: [PATCH 04/46] Remove debug statements in Test --- .../adios2/derived/TestBPDerivedCorrectness.cpp | 15 ++------------- 1 file changed, 2 insertions(+), 13 deletions(-) diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index 7611f26216..0e5228dfbe 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -248,8 +248,8 @@ std::vector> computecurl3D (std::vector inputX, std::v TEST(DerivedCorrectness, CurlCorrectnessTest) { - const size_t Nx = 5, Ny = 7, Nz = 11; - float error_limit = 0.000001; + const size_t Nx = 25, Ny = 70, Nz = 13; + float error_limit = 0.0000001; // Application variable std::vector simArray1(Nx * Ny * Nz); @@ -401,21 +401,10 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) sum_x += err_x; sum_y += err_y; sum_z += err_z; - std::cout << "Test curl at (" << x << ", " << y << ", " << z << ")\n"; - std::cout << "\tExpected: <" << curl_x << ", " << curl_y << ", " << curl_z << ">\n"; - std::cout << "\t Read: <" << readCurl[3 * idx] << ", " << readCurl[3 * idx + 1] << ", " << readCurl[3 * idx + 2] << ">" << std::endl; - std::cout << "\tRelative error: " << err_x << ", " << err_y << ", " << err_z << std::endl; } } } bpFileReader.Close(); - std::cout << "Finished reading curl. Ave rel error: " << (sum_x + sum_y + sum_z)/ ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)) << std::endl; - std::cout << "\tave in x: " << (sum_x / ((Nx * Ny * Nz) - inf_x)) << std::endl; - std::cout << "\tskipped x values (infinity): " << inf_x << std::endl; - std::cout << "\tave in y: " << (sum_y / ((Nx * Ny * Nz) - inf_y)) << std::endl; - std::cout << "\tskipped y values (infinity): " << inf_y << std::endl; - std::cout << "\tave in z: " << (sum_z / ((Nx * Ny * Nz) - inf_z)) << std::endl; - std::cout << "\tskipped z values (infinity): " << inf_z << std::endl; EXPECT_LT((sum_x + sum_y + sum_z) / ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)), error_limit); EXPECT_LT(sum_x / ((Nx * Ny * Nz) - inf_x), error_limit); EXPECT_LT(sum_y / ((Nx * Ny * Nz) - inf_y), error_limit); From 1a6c0112cbd699980d06c143614d5727876628b4 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Tue, 20 Feb 2024 10:16:15 -0500 Subject: [PATCH 05/46] Merging Bison3.8 parser into ADIOS (ERRORS - cannot build) --- source/adios2/CMakeLists.txt | 5 +- .../toolkit/derived/parser/ASTDriver.cpp | 85 + .../adios2/toolkit/derived/parser/ASTDriver.h | 60 + .../adios2/toolkit/derived/parser/ASTNode.cpp | 181 +- .../adios2/toolkit/derived/parser/ASTNode.h | 81 +- .../toolkit/derived/parser/CMakeLists.txt | 38 + .../adios2/toolkit/derived/parser/driver.cpp | 19 + .../adios2/toolkit/derived/parser/lexer.cpp | 1884 -------------- source/adios2/toolkit/derived/parser/lexer.l | 186 +- .../adios2/toolkit/derived/parser/parser.cpp | 1666 ------------ source/adios2/toolkit/derived/parser/parser.h | 110 - .../toolkit/derived/parser/parser.output | 350 --- source/adios2/toolkit/derived/parser/parser.y | 228 +- .../derived/parser/pregen-source/Makefile | 27 + .../derived/parser/pregen-source/lexer.cpp | 2233 +++++++++++++++++ .../parser/{ => pregen-source}/lexer.h | 295 ++- .../derived/parser/pregen-source/location.hh | 306 +++ .../derived/parser/pregen-source/parser.cpp | 1427 +++++++++++ .../derived/parser/pregen-source/parser.h | 1643 ++++++++++++ .../parser/pregen-source/parser.output | 597 +++++ .../derived/parser/pregen-source/simple-c | Bin 0 -> 384104 bytes .../derived/TestBPDerivedCorrectness.cpp | 258 +- 22 files changed, 7271 insertions(+), 4408 deletions(-) create mode 100644 source/adios2/toolkit/derived/parser/ASTDriver.cpp create mode 100644 source/adios2/toolkit/derived/parser/ASTDriver.h create mode 100644 source/adios2/toolkit/derived/parser/CMakeLists.txt create mode 100644 source/adios2/toolkit/derived/parser/driver.cpp delete mode 100644 source/adios2/toolkit/derived/parser/lexer.cpp delete mode 100644 source/adios2/toolkit/derived/parser/parser.cpp delete mode 100644 source/adios2/toolkit/derived/parser/parser.h delete mode 100644 source/adios2/toolkit/derived/parser/parser.output create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Makefile create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp rename source/adios2/toolkit/derived/parser/{ => pregen-source}/lexer.h (61%) create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/location.hh create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/parser.cpp create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/parser.h create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/parser.output create mode 100755 source/adios2/toolkit/derived/parser/pregen-source/simple-c diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index ff96f8e2c1..6a420f00a6 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -136,8 +136,9 @@ if (ADIOS2_HAVE_Derived_Variable) toolkit/derived/Function.cpp toolkit/derived/Function.tcc toolkit/derived/ExprHelper.h) add_library(adios2_core_derived - toolkit/derived/parser/lexer.cpp - toolkit/derived/parser/parser.cpp + toolkit/derived/parser/pregen-source/lexer.cpp + toolkit/derived/parser/pregen-source/parser.cpp + toolkit/derived/parser/ASTDriver.cpp toolkit/derived/parser/ASTNode.cpp) target_link_libraries(adios2_core PRIVATE adios2_core_derived) set(maybe_adios2_core_derived adios2_core_derived) diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.cpp b/source/adios2/toolkit/derived/parser/ASTDriver.cpp new file mode 100644 index 0000000000..ee91a3a6b0 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/ASTDriver.cpp @@ -0,0 +1,85 @@ +#include "ASTDriver.h" + +using indx_type = std::vector>; + +ASTDriver::ASTDriver() +{ +} + +ASTNode* ASTDriver::getAST () +{ + std::cout << "Getting AST. Nodes in holding: " << holding.size() << std::endl; + resolve(holding.top()); + return holding.top(); +} + +void ASTDriver::resolve(ASTNode* node) +{ + if (!node->get_alias().empty()) + { + std::tuple var_info; + var_info = lookup_var(node->get_alias()); + node->set_varname(std::get<0>(var_info)); + node->set_indices(std::get<1>(var_info)); + } + for (ASTNode *subexpr : node->get_subexprs()) + { + resolve(subexpr); + } +} + +std::tuple ASTDriver::lookup_var(const std::string alias) +{ + return aliases[alias]; +} + +std::string ASTDriver::lookup_var_name(const std::string alias) +{ + std::tuple var = aliases[alias]; + return std::get<0>(var); +} + +indx_type ASTDriver::lookup_var_indices(const std::string alias) +{ + std::tuple var = aliases[alias]; + return std::get<1>(var); +} + +void ASTDriver::add_lookup_entry(std::string alias, std::string var_name, indx_type indices) +{ + // aliases.insert(std::tuple>( + aliases.insert({alias, {var_name, indices}}); +} + +void ASTDriver::add_lookup_entry(std::string alias, std::string var_name) +{ + aliases.insert({alias, {var_name, {}}}); +} + +void ASTDriver::createNode(std::string op_name, size_t numsubexprs) +{ + std::cout << "Creating Node " << op_name << " with " << numsubexprs << " subexprs. Current number of ASTNodes in holding: " << holding.size() << std::endl; + + // TODO: convert string op_name to enum (check op existst) + ASTNode *node = new ASTNode(op_name, numsubexprs); + for (size_t i = 1; i <= numsubexprs; ++i) + { + ASTNode *subexpr = holding.top(); + node->insert_subexpr_n(subexpr, numsubexprs - i); + holding.pop(); + } + holding.push(node); +} + +void ASTDriver::createNode(std::string alias) +{ + ASTNode *node = new ASTNode("ALIAS", alias); + holding.push(node); +} + +void ASTDriver::createNode(std::string alias, indx_type indices) +{ + ASTNode *node = new ASTNode("INDEX", indices); + node->pushback_subexpr(new ASTNode("ALIAS", alias)); + holding.push(node); +} diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.h b/source/adios2/toolkit/derived/parser/ASTDriver.h new file mode 100644 index 0000000000..3f1ff646c3 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/ASTDriver.h @@ -0,0 +1,60 @@ +#ifndef ASTDRIVER_HH_ +# define ASTDRIVER_HH_ + +#include +#include +#include +#include +#include "parser.h" +#include "ASTNode.h" + +# define YY_DECL \ + adios2::detail::parser::symbol_type yylex (ASTDriver& drv) +YY_DECL; + +using indx_type = std::vector>; + +class ASTDriver +{ +public: + ASTDriver (); + + // Defined in lexer.l + ASTNode *parse (const char* input); + + ASTNode* getAST (); + + void resolve (ASTNode *node); + + std::tuple lookup_var(const std::string alias); + std::string lookup_var_name(const std::string alias); + indx_type lookup_var_indices(const std::string alias); + + void add_lookup_entry(std::string alias, std::string var_name, indx_type indices); + void add_lookup_entry(std::string alias, std::string var_name); + + void createNode(std::string, size_t); + void createNode(std::string); + void createNode(std::string, indx_type); + + // Whether to generate parser debug traces. + bool trace_parsing; + // Whether to generate scanner debug traces. + bool trace_scanning; + // The token's location used by the scanner. + adios2::detail::location location; + +private: + ASTNode* root; + + // count of how many ASTNodes exist + size_t num_nodes; + + // While parsing, holds ASTNodes until parent node is created + // (since root node is created last from bottom up design) + std::stack holding; + + // map alias names to variable names and indices from alias definition + std::map> aliases; +}; +#endif // ! ASTDRIVER_HH_ diff --git a/source/adios2/toolkit/derived/parser/ASTNode.cpp b/source/adios2/toolkit/derived/parser/ASTNode.cpp index 5cbc07322d..cf2e84b459 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.cpp +++ b/source/adios2/toolkit/derived/parser/ASTNode.cpp @@ -1,143 +1,132 @@ -#ifndef ADIOS2_DERIVED_PARSER_ASTNODE_CPP_ -#define ADIOS2_DERIVED_PARSER_ASTNODE_CPP_ +/* ASTNode for calc++. -*- C++ -*- -#include "ASTNode.h" + Copyright (C) 2005-2015, 2018-2021 Free Software Foundation, Inc. -namespace adios2 -{ -namespace detail -{ + This file is part of Bison, the GNU Compiler Compiler. -/*****************************************/ -// alias maps to pair of path and indices (indices may be empty string) -std::map> ASTNode::var_lookup; + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. -ASTNode::ASTNode() {} + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. -ASTNode::ASTNode(ExpressionOperator op) : operation(op) {} + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +#include "ASTNode.h" -ASTNode::ASTNode(ExpressionOperator op, const char *str) : operation(op) +ASTNode::ASTNode () { - switch (operation) - { - case ExpressionOperator::OP_ALIAS: - alias = str; - break; - case ExpressionOperator::OP_PATH: - alias = str; - break; - case ExpressionOperator::OP_INDEX: - indices = str; - break; - default: - // TODO: Make some error - // std::cout << "***That's a problem... ASTNode constructed with string should be alias - // type, path type, or index type\n"; - break; - } } -ASTNode::ASTNode(ExpressionOperator op, double val) : operation(op), value(val) {} +ASTNode::ASTNode (std::string op) +{ + opname = op; +} -ASTNode::ASTNode(ExpressionOperator op, ASTNode *e) : operation(op) { sub_expr.push_back(e); } +ASTNode::ASTNode (std::string op, size_t numsubexprs) +{ + opname = op; + sub_exprs.resize(numsubexprs); +} -// for index -ASTNode::ASTNode(ExpressionOperator op, ASTNode *e, const char *str) : operation(op), indices(str) +ASTNode::ASTNode (std::string op, std::string a) { - sub_expr.push_back(e); + opname = op; + alias = a; } -ASTNode::ASTNode(ExpressionOperator op, ASTNode *e1, ASTNode *e2) : operation(op) +ASTNode::ASTNode (std::string op, std::vector> i) { - sub_expr.push_back(e1); - sub_expr.push_back(e2); + opname = op; + indices = i; } -// Copy constructor -ASTNode::ASTNode(const ASTNode &e) -: operation(e.operation), alias(e.alias), value(e.value), sub_expr(e.sub_expr) +void ASTNode::set_num_subexprs(size_t n) { + sub_exprs.resize(n); } -ASTNode::~ASTNode() +void ASTNode::pushback_subexpr(ASTNode *subexpr) { - for (ASTNode *e : sub_expr) - { - delete e; - } + sub_exprs.push_back(subexpr); } -std::pair ASTNode::lookup_var(const std::string var_alias) +void ASTNode::insert_subexpr_n(ASTNode *subexpr, size_t index) { - return var_lookup[var_alias]; + sub_exprs[index] = subexpr; } -std::string ASTNode::lookup_var_path(const std::string var_alias) +std::string ASTNode::printpretty(std::string indent) { - return var_lookup[var_alias].first; + std::string result = indent + opname + "\n"; + if (!alias.empty()) + { + result += indent + "(alias: " + alias + ")\n"; + } + if (!varname.empty()) + { + result += indent + "(varname: " + varname + ")\n"; + } + else if (!alias.empty()) + { + result += indent + "(varname not found)\n"; + } + if (!indices.empty()) + { + result += indent + "(indices: [ "; + for (std::tuple idx: indices) + { + result += std::to_string(std::get<0>(idx)) + ":"; + result += std::to_string(std::get<1>(idx)) + ":"; + result += std::to_string(std::get<2>(idx)) + " "; + } + result += "] )\n"; + } + for (ASTNode *node: sub_exprs) + { + result += node->printpretty(indent + " "); + } + + return result; } -std::string ASTNode::lookup_var_indices(const std::string var_alias) +std::vector ASTNode::get_subexprs() { - return var_lookup[var_alias].second; + return sub_exprs; } -void ASTNode::add_lookup_entry(const std::string alias, const std::string var_name, - const std::string indices) +std::string ASTNode::get_opname() { - // std::cout << "Adding alias to lookup table:\n\talias: " << alias << "\n\tvar_name: " << - // var_name << "\n\tindices: " << indices << std::endl; - var_lookup[alias] = std::make_pair(var_name, indices); + return opname; } -void ASTNode::add_subexpr(ASTNode *e) { sub_expr.push_back(e); } -void ASTNode::add_back_subexpr(ASTNode *e, size_t n) +std::string ASTNode::get_alias() { - size_t index = sub_expr.size() - n; - // std::cout << "ASTNode add_back_subexpr index: " << index << std::endl; - // if (index > 0 && sub_expr[index] == nullptr) - sub_expr[index] = e; + return alias; } -void ASTNode::extend_subexprs(size_t n) +std::string ASTNode::get_varname() { - // std::cout << "ASTNode extending subexprs from size " << sub_expr.size() << " to " << - // (sub_expr.size() + n) << std::endl; - sub_expr.resize(sub_expr.size() + n); + return varname; } -void ASTNode::printpretty(std::string indent) +std::vector> ASTNode::get_indices() { - std::cout << indent << get_op_name(operation) << ":"; - if (operation == ExpressionOperator::OP_ALIAS) - { - std::cout << " (alias " << alias << " maps to Variable '"; - std::cout << lookup_var_path(alias) << "'"; - if (lookup_var_indices(alias) != "") - { - std::cout << " [" << lookup_var_indices(alias) << "]"; - } - std::cout << ")"; - } - else if (operation == ExpressionOperator::OP_PATH) - { - std::cout << " (" << alias << ")"; - } - else if (operation == ExpressionOperator::OP_INDEX) - { - std::cout << " [" << indices << "]"; - } - std::cout << std::endl; - for (ASTNode *e : sub_expr) - { - if (e != nullptr) - e->printpretty(indent + " "); - else - std::cout << "sub_expr is nullptr" << std::endl; - } + return indices; } +void ASTNode::set_varname(const std::string s) +{ + varname = s; } + +void ASTNode::set_indices(const std::vector> idx) +{ + indices = idx; } -#endif diff --git a/source/adios2/toolkit/derived/parser/ASTNode.h b/source/adios2/toolkit/derived/parser/ASTNode.h index 72cec1a812..6650a26694 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.h +++ b/source/adios2/toolkit/derived/parser/ASTNode.h @@ -1,58 +1,37 @@ -#ifndef ADIOS2_DERIVED_PARSER_ASTNODE_H_ -#define ADIOS2_DERIVED_PARSER_ASTNODE_H_ - -#include -#include -#include +#ifndef ASTNODE_HH +# define ASTNODE_HH #include - -#include "../ExprHelper.h" - -/*****************************************/ - -namespace adios2 -{ -namespace detail -{ +#include +#include class ASTNode { public: - ASTNode(); - ASTNode(ExpressionOperator); - ASTNode(ExpressionOperator, const char *a); - ASTNode(ExpressionOperator, double val); - ASTNode(ExpressionOperator, ASTNode *e); - ASTNode(ExpressionOperator, ASTNode *e, const char *i); - ASTNode(ExpressionOperator, ASTNode *e1, ASTNode *e2); - - // Copy constructor - ASTNode(const ASTNode &e); - - ~ASTNode(); - - static std::pair lookup_var(const std::string var_alias); - static std::string lookup_var_path(const std::string var_alias); - static std::string lookup_var_indices(const std::string var_alias); - static void add_lookup_entry(const std::string alias, const std::string var_name, - const std::string indices); - - void add_subexpr(ASTNode *e); - void add_back_subexpr(ASTNode *e, size_t i); - void extend_subexprs(size_t n); - void infer_type(); - void printpretty(std::string indent = ""); - - // private: - ExpressionOperator operation; - std::string alias; - std::string indices; - double value; - std::vector sub_expr; - - static std::map> var_lookup; + ASTNode (); + ASTNode (std::string); + ASTNode (std::string, size_t); + ASTNode (std::string, std::string); + ASTNode (std::string, std::vector>); + + void set_num_subexprs(size_t); + void pushback_subexpr(ASTNode*); + void insert_subexpr_n(ASTNode*, size_t); + std::string printpretty(std::string); + + std::vector get_subexprs(); + std::string get_opname(); + std::string get_alias(); + std::string get_varname(); + std::vector> get_indices(); + void set_varname(const std::string); + void set_indices(const std::vector>); + +private: + std::vector sub_exprs; + std::string opname; + std::string alias; + std::string varname; + std::vector> indices; }; +#endif // ! ASTNODE_HH -} -} -#endif \ No newline at end of file diff --git a/source/adios2/toolkit/derived/parser/CMakeLists.txt b/source/adios2/toolkit/derived/parser/CMakeLists.txt new file mode 100644 index 0000000000..edf04d7586 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/CMakeLists.txt @@ -0,0 +1,38 @@ +project(simple-test) +cmake_minimum_required(VERSION 3.18) +enable_language(CXX) +set(CMAKE_CXX_STANDARD 11) + +set(PARSER_SOURCE "./" CACHE PATH "Expression Parser source code") + +# Hardcoded for debugging - DELETE +set(BISON_EXECUTABLE "/usr/local/Cellar/bison/3.8.2/bin/bison" CACHE PATH "Bison executable") +set(FLEX_EXECUTABLE "/usr/local/Cellar/flex/2.6.4_2/bin/flex" CACHE PATH "Flex executable") + +find_package(BISON) +find_package(FLEX) + +# if(NOT ADIOS2_EXPRESSIONS_REGEN OR NOT BISON_FOUND OR NOT FLEX_FOUND) +# +# else() + BISON_TARGET(MyParser + parser.y + ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp + DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/parser.h) + FLEX_TARGET(MyScanner + lexer.l + ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp + DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/lexer.h) + ADD_FLEX_BISON_DEPENDENCY(MyScanner MyParser) +# endif() + +include_directories(${CMAKE_CURRENT_BINARY_DIR} ${PARSER_SOURCE}) +add_executable(simple-test + ${PARSER_SOURCE}/driver.cpp + ${PARSER_SOURCE}/ASTNode.cpp + ${PARSER_SOURCE}/ASTNode.h + ${BISON_MyParser_OUTPUTS} + ${FLEX_MyScanner_OUTPUTS} +) + +target_include_directories(simple-test PRIVATE ${CMAKE_CURRENT_BINARY_DIR} ${PARSER_SOURCE}) diff --git a/source/adios2/toolkit/derived/parser/driver.cpp b/source/adios2/toolkit/derived/parser/driver.cpp new file mode 100644 index 0000000000..a9bfe91e7b --- /dev/null +++ b/source/adios2/toolkit/derived/parser/driver.cpp @@ -0,0 +1,19 @@ +#include +#include +#include "ASTDriver.h" + +int +main (int argc, char *argv[]) +{ + ASTDriver drv; + // char* str_expr = "one := 1\ntwo := 2\nthree := 3\n(one + two * three) * two * three"; + char* str_expr = "var x:= sim1/points/x\nvar y := sim1/points/y\nvar z:=sim_1/points-more/x[ , , ::5]\nvar a:=sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; + std::cout << "Parse input: " << str_expr << std::endl; + + ASTNode *result = drv.parse(str_expr); + + std::cout << "Result: " << std::endl; + std::cout << result->printpretty(""); + + return 0; +} diff --git a/source/adios2/toolkit/derived/parser/lexer.cpp b/source/adios2/toolkit/derived/parser/lexer.cpp deleted file mode 100644 index 03b101c191..0000000000 --- a/source/adios2/toolkit/derived/parser/lexer.cpp +++ /dev/null @@ -1,1884 +0,0 @@ -#line 1 "lexer.cpp" - -#line 3 "lexer.cpp" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -typedef uint64_t flex_uint64_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767 - 1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647 - 1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* Returned upon end-of-file. */ -#define YY_NULL 0 - -/* Promotes a possibly negative, possibly signed char to an - * integer in range [0..255] for use as an array index. - */ -#define YY_SC_TO_UI(c) ((YY_CHAR)(c)) - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN (yy_start) = 1 + 2 * -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START (((yy_start)-1) / 2) -#define YYSTATE YY_START -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart(yyin) -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -extern yy_size_t yyleng; - -extern FILE *yyin, *yyout; - -#define EOB_ACT_CONTINUE_SCAN 0 -#define EOB_ACT_END_OF_FILE 1 -#define EOB_ACT_LAST_MATCH 2 - -#define YY_LESS_LINENO(n) -#define YY_LINENO_REWIND_TO(ptr) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg); \ - *yy_cp = (yy_hold_char); \ - YY_RESTORE_YY_MORE_OFFSET(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up yytext again */ \ - } while (0) -#define unput(c) yyunput(c, (yytext_ptr)) - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state -{ - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - yy_size_t yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via yyrestart()), so that the user can continue scanning by - * just pointing yyin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 -}; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* Stack of input buffers. */ -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE *yy_buffer_stack = NULL; /**< Stack as an array. */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ((yy_buffer_stack) ? (yy_buffer_stack)[(yy_buffer_stack_top)] : NULL) -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] - -/* yy_hold_char holds the character lost when yytext is formed. */ -static char yy_hold_char; -static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ -yy_size_t yyleng; - -/* Points to current character in buffer. */ -static char *yy_c_buf_p = NULL; -static int yy_init = 0; /* whether we need to initialize */ -static int yy_start = 0; /* start state number */ - -/* Flag which is used to allow yywrap()'s to do buffer switches - * instead of setting up a fresh yyin. A bit of a hack ... - */ -static int yy_did_buffer_switch_on_eof; - -void yyrestart(FILE *input_file); -void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer); -YY_BUFFER_STATE yy_create_buffer(FILE *file, int size); -void yy_delete_buffer(YY_BUFFER_STATE b); -void yy_flush_buffer(YY_BUFFER_STATE b); -void yypush_buffer_state(YY_BUFFER_STATE new_buffer); -void yypop_buffer_state(void); - -static void yyensure_buffer_stack(void); -static void yy_load_buffer_state(void); -static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file); -#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER) - -YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size); -YY_BUFFER_STATE yy_scan_string(const char *yy_str); -YY_BUFFER_STATE yy_scan_bytes(const char *bytes, yy_size_t len); - -void *yyalloc(yy_size_t); -void *yyrealloc(void *, yy_size_t); -void yyfree(void *); - -#define yy_new_buffer yy_create_buffer -#define yy_set_interactive(is_interactive) \ - { \ - if (!YY_CURRENT_BUFFER) \ - { \ - yyensure_buffer_stack(); \ - YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ - } -#define yy_set_bol(at_bol) \ - { \ - if (!YY_CURRENT_BUFFER) \ - { \ - yyensure_buffer_stack(); \ - YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ - } -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* Begin user sect3 */ - -#define yywrap() (/*CONSTCOND*/ 1) -#define YY_SKIP_YYWRAP -typedef flex_uint8_t YY_CHAR; - -FILE *yyin = NULL, *yyout = NULL; - -typedef int yy_state_type; - -extern int yylineno; -int yylineno = 1; - -extern char *yytext; -#ifdef yytext_ptr -#undef yytext_ptr -#endif -#define yytext_ptr yytext - -static yy_state_type yy_get_previous_state(void); -static yy_state_type yy_try_NUL_trans(yy_state_type current_state); -static int yy_get_next_buffer(void); -static void yynoreturn yy_fatal_error(const char *msg); - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up yytext. - */ -#define YY_DO_BEFORE_ACTION \ - (yytext_ptr) = yy_bp; \ - yyleng = (yy_size_t)(yy_cp - yy_bp); \ - (yy_hold_char) = *yy_cp; \ - *yy_cp = '\0'; \ - (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 24 -#define YY_END_OF_BUFFER 25 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info -{ - flex_int32_t yy_verify; - flex_int32_t yy_nxt; -}; -static const flex_int16_t yy_accept[91] = { - 0, 0, 0, 25, 23, 17, 18, 23, 23, 6, 7, 3, 1, 8, 2, 23, 4, 16, 23, 19, 19, 23, 5, - 19, 19, 19, 19, 19, 18, 17, 0, 0, 0, 16, 16, 16, 19, 19, 0, 20, 19, 0, 0, 19, 19, 19, - 19, 19, 19, 19, 0, 21, 0, 0, 16, 0, 0, 16, 20, 20, 18, 0, 22, 0, 0, 9, 12, 19, 19, - 11, 19, 13, 18, 0, 16, 20, 0, 0, 0, 15, 19, 10, 0, 0, 19, 0, 19, 19, 19, 14, 0}; - -static const YY_CHAR yy_ec[256] = { - 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 4, 1, 1, 5, 6, 7, - 8, 9, 10, 11, 12, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 1, 1, 1, 1, - 1, 1, 16, 16, 16, 16, 17, 18, 16, 16, 16, 16, 16, 16, 16, 16, 19, 16, 16, 16, 16, - 16, 16, 16, 16, 16, 16, 16, 20, 21, 22, 23, 24, 1, 25, 26, 27, 28, - - 29, 26, 30, 26, 31, 26, 26, 32, 33, 34, 35, 26, 36, 37, 38, 39, 40, 26, 26, 26, 26, - 26, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}; - -static const YY_CHAR yy_meta[42] = {0, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 3, 4, 5, 6, 1, 6, 6, 6, 6, 1, - 5, 1, 1, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 1}; - -static const flex_int16_t yy_base[98] = { - 0, 0, 0, 221, 254, 218, 254, 190, 29, 254, 254, 254, 254, 254, 254, 203, 254, - 32, 34, 204, 33, 42, 254, 39, 42, 47, 48, 50, 254, 213, 180, 50, 75, 199, - 52, 56, 200, 81, 84, 89, 89, 101, 103, 66, 53, 75, 92, 94, 97, 102, 183, - 254, 116, 128, 118, 134, 196, 112, 140, 144, 196, 105, 254, 145, 152, 195, 193, 138, - 144, 157, 132, 126, 254, 162, 117, 166, 174, 167, 181, 113, 173, 71, 178, 184, 160, - 187, 188, 190, 134, 64, 254, 224, 227, 229, 234, 238, 243, 247 - -}; - -static const flex_int16_t yy_def[98] = { - 0, 90, 1, 90, 90, 90, 90, 90, 91, 90, 90, 90, 90, 90, 90, 90, 90, 92, 93, 92, - 92, 90, 90, 92, 92, 92, 92, 92, 90, 90, 90, 91, 94, 90, 90, 92, 92, 92, 93, 95, - 92, 90, 90, 92, 92, 92, 92, 92, 92, 92, 90, 90, 96, 94, 90, 90, 90, 92, 97, 95, - 92, 90, 90, 90, 90, 92, 92, 92, 92, 92, 92, 92, 90, 96, 90, 97, 90, 90, 90, 92, - 92, 92, 90, 90, 92, 90, 92, 92, 92, 92, 0, 90, 90, 90, 90, 90, 90, 90 - -}; - -static const flex_int16_t yy_nxt[296] = { - 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 19, 19, 21, 4, 4, 22, - 19, 23, 19, 24, 19, 19, 19, 19, 19, 25, 19, 19, 19, 19, 26, 27, 19, 28, 31, 31, 34, 90, 35, 38, - 38, 37, 31, 90, 40, 31, 90, 38, 41, 42, 38, 90, 90, 37, 90, 31, 31, 90, 54, 43, 34, 55, 35, 31, - 46, 37, 31, 49, 90, 44, 90, 47, 51, 55, 45, 90, 48, 37, 52, 90, 52, 52, 56, 66, 56, 90, 65, 57, - 52, 38, 38, 52, 58, - - 90, 58, 58, 90, 38, 90, 60, 38, 90, 58, 61, 67, 58, 90, 41, 42, 63, 64, 76, 77, 51, 68, 62, 90, - 90, 57, 52, 69, 52, 52, 74, 54, 51, 70, 55, 71, 52, 90, 52, 52, 52, 52, 56, 90, 56, 90, 55, 74, - 52, 90, 58, 52, 58, 58, 58, 90, 58, 58, 63, 64, 58, 61, 89, 58, 58, 78, 51, 58, 90, 79, 81, 90, - 52, 62, 52, 52, 58, 80, 58, 58, 82, 83, 52, 61, 90, 52, 58, 76, 77, 58, 61, 82, 83, 61, 78, 62, - 61, 85, 86, 90, - - 85, 90, 62, 84, 90, 62, 90, 90, 62, 74, 72, 90, 33, 50, 29, 90, 33, 88, 30, 29, 90, 90, 90, 90, - 90, 90, 90, 87, 32, 32, 36, 90, 36, 39, 39, 53, 53, 90, 53, 53, 59, 90, 59, 59, 73, 73, 90, 73, - 73, 75, 90, 75, 75, 3, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90 - -}; - -static const flex_int16_t yy_chk[296] = { - 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 8, 17, 20, 17, 18, - 18, 17, 8, 23, 20, 8, 24, 18, 21, 21, 18, 25, 26, 17, 27, 31, 31, 44, 34, 23, 35, 34, 35, 31, - 25, 35, 31, 27, 89, 24, 43, 26, 32, 34, 24, 81, 26, 35, 32, 45, 32, 32, 37, 44, 37, 37, 43, 37, - 32, 38, 38, 32, 39, - - 40, 39, 39, 46, 38, 47, 40, 38, 48, 39, 41, 45, 39, 49, 41, 41, 42, 42, 61, 61, 52, 46, 41, 57, - 79, 57, 52, 47, 52, 52, 74, 54, 53, 48, 54, 49, 52, 71, 53, 52, 53, 53, 55, 70, 55, 88, 54, 55, - 53, 67, 58, 53, 58, 58, 59, 68, 59, 59, 63, 63, 58, 64, 88, 58, 59, 64, 73, 59, 69, 67, 70, 84, - 73, 64, 73, 73, 75, 68, 75, 75, 77, 77, 73, 76, 80, 73, 75, 76, 76, 75, 78, 82, 82, 83, 78, 76, - 85, 83, 84, 86, - - 85, 87, 78, 80, 66, 83, 65, 60, 85, 56, 50, 36, 33, 30, 29, 19, 15, 87, 7, 5, 3, 0, 0, 0, - 0, 0, 0, 86, 91, 91, 92, 0, 92, 93, 93, 94, 94, 0, 94, 94, 95, 0, 95, 95, 96, 96, 0, 96, - 96, 97, 0, 97, 97, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90 - -}; - -static yy_state_type yy_last_accepting_state; -static char *yy_last_accepting_cpos; - -extern int yy_flex_debug; -int yy_flex_debug = 0; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#define REJECT reject_used_but_not_detected -#define yymore() yymore_used_but_not_detected -#define YY_MORE_ADJ 0 -#define YY_RESTORE_YY_MORE_OFFSET -char *yytext; -#line 1 "lexer.l" -#line 2 "lexer.l" -#include "parser.h" -#define YY_USER_ACTION yylloc.first_line = yylloc.last_line = yylineno; -#line 544 "lexer.cpp" -#line 545 "lexer.cpp" - -#define INITIAL 0 - -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -static int yy_init_globals(void); - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy(void); - -int yyget_debug(void); - -void yyset_debug(int debug_flag); - -YY_EXTRA_TYPE yyget_extra(void); - -void yyset_extra(YY_EXTRA_TYPE user_defined); - -FILE *yyget_in(void); - -void yyset_in(FILE *_in_str); - -FILE *yyget_out(void); - -void yyset_out(FILE *_out_str); - -yy_size_t yyget_leng(void); - -char *yyget_text(void); - -int yyget_lineno(void); - -void yyset_lineno(int _line_number); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap(void); -#else -extern int yywrap(void); -#endif -#endif - -#ifndef YY_NO_UNPUT - -static void yyunput(int c, char *buf_ptr); - -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy(char *, const char *, int); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen(const char *); -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput(void); -#else -static int input(void); -#endif - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO \ - do \ - { \ - if (fwrite(yytext, (size_t)yyleng, 1, yyout)) \ - { \ - } \ - } while (0) -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf, result, max_size) \ - if (YY_CURRENT_BUFFER_LVALUE->yy_is_interactive) \ - { \ - int c = '*'; \ - yy_size_t n; \ - for (n = 0; n < max_size && (c = getc(yyin)) != EOF && c != '\n'; ++n) \ - buf[n] = (char)c; \ - if (c == '\n') \ - buf[n++] = (char)c; \ - if (c == EOF && ferror(yyin)) \ - YY_FATAL_ERROR("input in flex scanner failed"); \ - result = n; \ - } \ - else \ - { \ - errno = 0; \ - while ((result = (int)fread(buf, 1, (yy_size_t)max_size, yyin)) == 0 && ferror(yyin)) \ - { \ - if (errno != EINTR) \ - { \ - YY_FATAL_ERROR("input in flex scanner failed"); \ - break; \ - } \ - errno = 0; \ - clearerr(yyin); \ - } \ - } - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yy_fatal_error(msg) -#endif - -/* end tables serialization structures and prototypes */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex(void); - -#define YY_DECL int yylex(void) -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after yytext and yyleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK /*LINTED*/ break; -#endif - -#define YY_RULE_SETUP YY_USER_ACTION - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - yy_state_type yy_current_state; - char *yy_cp, *yy_bp; - int yy_act; - - if (!(yy_init)) - { - (yy_init) = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if (!(yy_start)) - (yy_start) = 1; /* first start state */ - - if (!yyin) - yyin = stdin; - - if (!yyout) - yyout = stdout; - - if (!YY_CURRENT_BUFFER) - { - yyensure_buffer_stack(); - YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE); - } - - yy_load_buffer_state(); - } - - { -#line 12 "lexer.l" - -#line 765 "lexer.cpp" - - while (/*CONSTCOND*/ 1) /* loops until end-of-file is reached */ - { - yy_cp = (yy_c_buf_p); - - /* Support of yytext. */ - *yy_cp = (yy_hold_char); - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - - yy_current_state = (yy_start); - yy_match: - do - { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)]; - if (yy_accept[yy_current_state]) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) - { - yy_current_state = (int)yy_def[yy_current_state]; - if (yy_current_state >= 91) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - ++yy_cp; - } while (yy_base[yy_current_state] != 254); - - yy_find_action: - yy_act = yy_accept[yy_current_state]; - if (yy_act == 0) - { /* have to back up */ - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - yy_act = yy_accept[yy_current_state]; - } - - YY_DO_BEFORE_ACTION; - - do_action: /* This label is used only to access EOF actions. */ - - switch (yy_act) - { /* beginning of action switch */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = (yy_hold_char); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - - case 1: - YY_RULE_SETUP -#line 14 "lexer.l" - { - yylval.sval = strdup(yytext); - return OPERATOR; - } - YY_BREAK - case 2: - YY_RULE_SETUP -#line 15 "lexer.l" - { - yylval.sval = strdup(yytext); - return OPERATOR; - } - YY_BREAK - case 3: - YY_RULE_SETUP -#line 16 "lexer.l" - { - yylval.sval = strdup(yytext); - return OPERATOR; - } - YY_BREAK - case 4: - YY_RULE_SETUP -#line 17 "lexer.l" - { - yylval.sval = strdup(yytext); - return OPERATOR; - } - YY_BREAK - case 5: - YY_RULE_SETUP -#line 18 "lexer.l" - { - yylval.sval = strdup(yytext); - return OPERATOR; - } - YY_BREAK - case 6: - YY_RULE_SETUP -#line 19 "lexer.l" - { - return L_PAREN; - } - YY_BREAK - case 7: - YY_RULE_SETUP -#line 20 "lexer.l" - { - return R_PAREN; - } - YY_BREAK - case 8: - YY_RULE_SETUP -#line 21 "lexer.l" - { - return COMMA; - } - YY_BREAK - case 9: - YY_RULE_SETUP -#line 22 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 10: - YY_RULE_SETUP -#line 23 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 11: - YY_RULE_SETUP -#line 24 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 12: - YY_RULE_SETUP -#line 25 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 13: - YY_RULE_SETUP -#line 26 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 14: - YY_RULE_SETUP -#line 27 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 15: - YY_RULE_SETUP -#line 28 "lexer.l" - { - yylval.sval = strdup(yytext); - return FUNCTION; - } - YY_BREAK - case 16: - YY_RULE_SETUP -#line 31 "lexer.l" - { - yylval.dval = atof(yytext); - return NUMBER; - } - YY_BREAK - case 17: - YY_RULE_SETUP -#line 33 "lexer.l" - { /* ignore spaces */ - } - YY_BREAK - case 18: - /* rule 18 can match eol */ - YY_RULE_SETUP -#line 35 "lexer.l" - { - return ENDL; - } - YY_BREAK - case 19: - YY_RULE_SETUP -#line 37 "lexer.l" - { - yylval.sval = strdup(yytext); - return ALIAS; - } - YY_BREAK - case 20: - YY_RULE_SETUP -#line 39 "lexer.l" - { - yylval.sval = strndup(yytext + 1, strlen(yytext) - 1); - return PATH; - } - YY_BREAK - case 21: - YY_RULE_SETUP -#line 41 "lexer.l" - { - yylval.sval = strndup(yytext + 1, strlen(yytext) - 2); - return PATH; - } - YY_BREAK - case 22: - YY_RULE_SETUP -#line 43 "lexer.l" - { - yylval.sval = strndup(yytext + 1, strlen(yytext) - 2); - return INDICES; - } - YY_BREAK - case 23: - YY_RULE_SETUP -#line 45 "lexer.l" - { - printf("Error at line %d: unrecognized symbol \"%s\"\n", yylloc.first_line, - yytext); - exit(0); - } - YY_BREAK - case 24: - YY_RULE_SETUP -#line 47 "lexer.l" - ECHO; - YY_BREAK -#line 943 "lexer.cpp" - case YY_STATE_EOF(INITIAL): - yyterminate(); - - case YY_END_OF_BUFFER: { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int)(yy_cp - (yytext_ptr)) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = (yy_hold_char); - YY_RESTORE_YY_MORE_OFFSET - - if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * yylex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ((yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state(); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans(yy_current_state); - - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - - if (yy_next_state) - { - /* Consume the NUL. */ - yy_cp = ++(yy_c_buf_p); - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { - yy_cp = (yy_c_buf_p); - goto yy_find_action; - } - } - - else - switch (yy_get_next_buffer()) - { - case EOB_ACT_END_OF_FILE: { - (yy_did_buffer_switch_on_eof) = 0; - - if (yywrap()) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if (!(yy_did_buffer_switch_on_eof)) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state(); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - (yy_c_buf_p) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - - yy_current_state = yy_get_previous_state(); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR("fatal flex scanner internal error--no action found"); - } /* end of action switch */ - } /* end of scanning one token */ - } /* end of user's declarations */ -} /* end of yylex */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -static int yy_get_next_buffer(void) -{ - char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - char *source = (yytext_ptr); - int number_to_move, i; - int ret_val; - - if ((yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1]) - YY_FATAL_ERROR("fatal flex scanner internal error--end of buffer missed"); - - if (YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ((yy_c_buf_p) - (yytext_ptr)-YY_MORE_ADJ == 1) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int)((yy_c_buf_p) - (yytext_ptr)-1); - - for (i = 0; i < number_to_move; ++i) - *(dest++) = *(source++); - - if (YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; - - else - { - yy_size_t num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while (num_to_read <= 0) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; - - int yy_c_buf_p_offset = (int)((yy_c_buf_p)-b->yy_ch_buf); - - if (b->yy_is_our_buffer) - { - yy_size_t new_size = b->yy_buf_size * 2; - - if (new_size <= 0) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - yyrealloc((void *)b->yy_ch_buf, (yy_size_t)(b->yy_buf_size + 2)); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = NULL; - - if (!b->yy_ch_buf) - YY_FATAL_ERROR("fatal error - scanner input buffer overflow"); - - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - } - - if (num_to_read > YY_READ_BUF_SIZE) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT((&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), (yy_n_chars), num_to_read); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - if ((yy_n_chars) == 0) - { - if (number_to_move == YY_MORE_ADJ) - { - ret_val = EOB_ACT_END_OF_FILE; - yyrestart(yyin); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) - { - /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = - (char *)yyrealloc((void *)YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t)new_size); - if (!YY_CURRENT_BUFFER_LVALUE->yy_ch_buf) - YY_FATAL_ERROR("out of dynamic memory in yy_get_next_buffer()"); - /* "- 2" to take care of EOB's */ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int)(new_size - 2); - } - - (yy_n_chars) += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - -static yy_state_type yy_get_previous_state(void) -{ - yy_state_type yy_current_state; - char *yy_cp; - - yy_current_state = (yy_start); - - for (yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp) - { - YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 41); - if (yy_accept[yy_current_state]) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) - { - yy_current_state = (int)yy_def[yy_current_state]; - if (yy_current_state >= 91) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ -static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state) -{ - int yy_is_jam; - char *yy_cp = (yy_c_buf_p); - - YY_CHAR yy_c = 41; - if (yy_accept[yy_current_state]) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while (yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state) - { - yy_current_state = (int)yy_def[yy_current_state]; - if (yy_current_state >= 91) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 90); - - return yy_is_jam ? 0 : yy_current_state; -} - -#ifndef YY_NO_UNPUT - -static void yyunput(int c, char *yy_bp) -{ - char *yy_cp; - - yy_cp = (yy_c_buf_p); - - /* undo effects of setting up yytext */ - *yy_cp = (yy_hold_char); - - if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2) - { /* need to shift things up to make room */ - /* +2 for EOB chars. */ - yy_size_t number_to_move = (yy_n_chars) + 2; - char *dest = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2]; - char *source = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]; - - while (source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf) - *--dest = *--source; - - yy_cp += (int)(dest - source); - yy_bp += (int)(dest - source); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = - (int)YY_CURRENT_BUFFER_LVALUE->yy_buf_size; - - if (yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2) - YY_FATAL_ERROR("flex scanner push-back overflow"); - } - - *--yy_cp = (char)c; - - (yytext_ptr) = yy_bp; - (yy_hold_char) = *yy_cp; - (yy_c_buf_p) = yy_cp; -} - -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput(void) -#else -static int input(void) -#endif - -{ - int c; - - *(yy_c_buf_p) = (yy_hold_char); - - if (*(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ((yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]) - /* This was really a NUL. */ - *(yy_c_buf_p) = '\0'; - - else - { /* need more input */ - yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); - ++(yy_c_buf_p); - - switch (yy_get_next_buffer()) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - yyrestart(yyin); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: { - if (yywrap()) - return 0; - - if (!(yy_did_buffer_switch_on_eof)) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(); -#else - return input(); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + offset; - break; - } - } - } - - c = *(unsigned char *)(yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve yytext */ - (yy_hold_char) = *++(yy_c_buf_p); - - return c; -} -#endif /* ifndef YY_NO_INPUT */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * - * @note This function does not reset the start condition to @c INITIAL . - */ -void yyrestart(FILE *input_file) -{ - - if (!YY_CURRENT_BUFFER) - { - yyensure_buffer_stack(); - YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE); - } - - yy_init_buffer(YY_CURRENT_BUFFER, input_file); - yy_load_buffer_state(); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * - */ -void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer) -{ - - /* TODO. We should be able to replace this entire function body - * with - * yypop_buffer_state(); - * yypush_buffer_state(new_buffer); - */ - yyensure_buffer_stack(); - if (YY_CURRENT_BUFFER == new_buffer) - return; - - if (YY_CURRENT_BUFFER) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state(); - - /* We don't actually know whether we did this switch during - * EOF (yywrap()) processing, but the only time this flag - * is looked at is after yywrap() is called, so it's safe - * to go ahead and always set it. - */ - (yy_did_buffer_switch_on_eof) = 1; -} - -static void yy_load_buffer_state(void) -{ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - (yy_hold_char) = *(yy_c_buf_p); -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * - * @return the allocated buffer state. - */ -YY_BUFFER_STATE yy_create_buffer(FILE *file, int size) -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE)yyalloc(sizeof(struct yy_buffer_state)); - if (!b) - YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()"); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *)yyalloc((yy_size_t)(b->yy_buf_size + 2)); - if (!b->yy_ch_buf) - YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()"); - - b->yy_is_our_buffer = 1; - - yy_init_buffer(b, file); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with yy_create_buffer() - * - */ -void yy_delete_buffer(YY_BUFFER_STATE b) -{ - - if (!b) - return; - - if (b == YY_CURRENT_BUFFER) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE)0; - - if (b->yy_is_our_buffer) - yyfree((void *)b->yy_ch_buf); - - yyfree((void *)b); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a yyrestart() or at EOF. - */ -static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file) - -{ - int oerrno = errno; - - yy_flush_buffer(b); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then yy_init_buffer was _probably_ - * called from yyrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER) - { - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = file ? (isatty(fileno(file)) > 0) : 0; - - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * - */ -void yy_flush_buffer(YY_BUFFER_STATE b) -{ - if (!b) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if (b == YY_CURRENT_BUFFER) - yy_load_buffer_state(); -} - -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * - */ -void yypush_buffer_state(YY_BUFFER_STATE new_buffer) -{ - if (new_buffer == NULL) - return; - - yyensure_buffer_stack(); - - /* This block is copied from yy_switch_to_buffer. */ - if (YY_CURRENT_BUFFER) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - (yy_buffer_stack_top)++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state(); - (yy_did_buffer_switch_on_eof) = 1; -} - -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * - */ -void yypop_buffer_state(void) -{ - if (!YY_CURRENT_BUFFER) - return; - - yy_delete_buffer(YY_CURRENT_BUFFER); - YY_CURRENT_BUFFER_LVALUE = NULL; - if ((yy_buffer_stack_top) > 0) - --(yy_buffer_stack_top); - - if (YY_CURRENT_BUFFER) - { - yy_load_buffer_state(); - (yy_did_buffer_switch_on_eof) = 1; - } -} - -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -static void yyensure_buffer_stack(void) -{ - yy_size_t num_to_alloc; - - if (!(yy_buffer_stack)) - { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = - (struct yy_buffer_state **)yyalloc(num_to_alloc * sizeof(struct yy_buffer_state *)); - if (!(yy_buffer_stack)) - YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()"); - - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state *)); - - (yy_buffer_stack_max) = num_to_alloc; - (yy_buffer_stack_top) = 0; - return; - } - - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1) - { - - /* Increase the buffer to prepare for a possible push. */ - yy_size_t grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state **)yyrealloc( - (yy_buffer_stack), num_to_alloc * sizeof(struct yy_buffer_state *)); - if (!(yy_buffer_stack)) - YY_FATAL_ERROR("out of dynamic memory in yyensure_buffer_stack()"); - - /* zero only the new slots.*/ - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, - grow_size * sizeof(struct yy_buffer_state *)); - (yy_buffer_stack_max) = num_to_alloc; - } -} - -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size) -{ - YY_BUFFER_STATE b; - - if (size < 2 || base[size - 2] != YY_END_OF_BUFFER_CHAR || - base[size - 1] != YY_END_OF_BUFFER_CHAR) - /* They forgot to leave room for the EOB's. */ - return NULL; - - b = (YY_BUFFER_STATE)yyalloc(sizeof(struct yy_buffer_state)); - if (!b) - YY_FATAL_ERROR("out of dynamic memory in yy_scan_buffer()"); - - b->yy_buf_size = (int)(size - 2); /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = NULL; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - yy_switch_to_buffer(b); - - return b; -} - -/** Setup the input buffer state to scan a string. The next call to yylex() will - * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan - * - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * yy_scan_bytes() instead. - */ -YY_BUFFER_STATE yy_scan_string(const char *yystr) -{ - - return yy_scan_bytes(yystr, (int)strlen(yystr)); -} - -/** Setup the input buffer state to scan the given bytes. The next call to yylex() will - * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_bytes(const char *yybytes, yy_size_t _yybytes_len) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - yy_size_t i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = (yy_size_t)(_yybytes_len + 2); - buf = (char *)yyalloc(n); - if (!buf) - YY_FATAL_ERROR("out of dynamic memory in yy_scan_bytes()"); - - for (i = 0; i < _yybytes_len; ++i) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len + 1] = YY_END_OF_BUFFER_CHAR; - - b = yy_scan_buffer(buf, n); - if (!b) - YY_FATAL_ERROR("bad buffer in yy_scan_bytes()"); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -static void yynoreturn yy_fatal_error(const char *msg) -{ - fprintf(stderr, "%s\n", msg); - exit(YY_EXIT_FAILURE); -} - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - yy_size_t yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg); \ - yytext[yyleng] = (yy_hold_char); \ - (yy_c_buf_p) = yytext + yyless_macro_arg; \ - (yy_hold_char) = *(yy_c_buf_p); \ - *(yy_c_buf_p) = '\0'; \ - yyleng = yyless_macro_arg; \ - } while (0) - -/* Accessor methods (get/set functions) to struct members. */ - -/** Get the current line number. - * - */ -int yyget_lineno(void) { return yylineno; } - -/** Get the input stream. - * - */ -FILE *yyget_in(void) { return yyin; } - -/** Get the output stream. - * - */ -FILE *yyget_out(void) { return yyout; } - -/** Get the length of the current token. - * - */ -yy_size_t yyget_leng(void) { return yyleng; } - -/** Get the current token. - * - */ - -char *yyget_text(void) { return yytext; } - -/** Set the current line number. - * @param _line_number line number - * - */ -void yyset_lineno(int _line_number) { yylineno = _line_number; } - -/** Set the input stream. This does not discard the current - * input buffer. - * @param _in_str A readable stream. - * - * @see yy_switch_to_buffer - */ -void yyset_in(FILE *_in_str) { yyin = _in_str; } - -void yyset_out(FILE *_out_str) { yyout = _out_str; } - -int yyget_debug(void) { return yy_flex_debug; } - -void yyset_debug(int _bdebug) { yy_flex_debug = _bdebug; } - -static int yy_init_globals(void) -{ - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from yylex_destroy(), so don't allocate here. - */ - - (yy_buffer_stack) = NULL; - (yy_buffer_stack_top) = 0; - (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = NULL; - (yy_init) = 0; - (yy_start) = 0; - -/* Defined in main.c */ -#ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; -#else - yyin = NULL; - yyout = NULL; -#endif - - /* For future reference: Set errno on error, since we are called by - * yylex_init() - */ - return 0; -} - -/* yylex_destroy is for both reentrant and non-reentrant scanners. */ -int yylex_destroy(void) -{ - - /* Pop the buffer stack, destroying each element. */ - while (YY_CURRENT_BUFFER) - { - yy_delete_buffer(YY_CURRENT_BUFFER); - YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(); - } - - /* Destroy the stack itself. */ - yyfree((yy_buffer_stack)); - (yy_buffer_stack) = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * yylex() is called, initialization will occur. */ - yy_init_globals(); - - return 0; -} - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy(char *s1, const char *s2, int n) -{ - - int i; - for (i = 0; i < n; ++i) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen(const char *s) -{ - int n; - for (n = 0; s[n]; ++n) - ; - - return n; -} -#endif - -void *yyalloc(yy_size_t size) { return malloc(size); } - -void *yyrealloc(void *ptr, yy_size_t size) -{ - - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return realloc(ptr, size); -} - -void yyfree(void *ptr) { free((char *)ptr); /* see yyrealloc() for (char *) cast */ } - -#define YYTABLES_NAME "yytables" - -#line 47 "lexer.l" diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index f81a98bcf9..be321d9dc8 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -1,47 +1,169 @@ -%{ -#include "parser.hpp" -#define YY_USER_ACTION yylloc.first_line = yylloc.last_line = yylineno; +/* Scanner for calc++. -*- C++ -*- + + Copyright (C) 2005-2015, 2018-2021 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ + +%{ /* -*- C++ -*- */ +# include +# include +# include +# include // strerror +# include +#include "ASTDriver.h" +# include "parser.h" %} -%option noyywrap +%{ +#if defined __clang__ +# define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#endif +// Clang and ICC like to pretend they are GCC. +#if defined __GNUC__ && !defined __clang__ && !defined __ICC +# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#endif -DIGIT [0-9] -CHAR ([a-z]|[A-Z]) - -%% +// Pacify warnings in yy_init_buffer (observed with Flex 2.6.4) +// and GCC 6.4.0, 7.3.0 with -O3. +#if defined GCC_VERSION && 600 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wnull-dereference" +#endif + +// This example uses Flex's C back end, yet compiles it as C++. +// So expect warnings about C style casts and NULL. +#if defined CLANG_VERSION && 500 <= CLANG_VERSION +# pragma clang diagnostic ignored "-Wold-style-cast" +# pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#elif defined GCC_VERSION && 407 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wold-style-cast" +# pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif -"+" {yylval.sval=strdup(yytext); return OPERATOR;} -"-" {yylval.sval=strdup(yytext); return OPERATOR;} -"*" {yylval.sval=strdup(yytext); return OPERATOR;} -"/" {yylval.sval=strdup(yytext); return OPERATOR;} -"^" {yylval.sval=strdup(yytext); return OPERATOR;} -"(" {return L_PAREN;} -")" {return R_PAREN;} -"," {return COMMA;} -"add" {yylval.sval=strdup(yytext); return FUNCTION;} -"sqrt" {yylval.sval=strdup(yytext); return FUNCTION;} -"sin" {yylval.sval=strdup(yytext); return FUNCTION;} -"cos" {yylval.sval=strdup(yytext); return FUNCTION;} -"tan" {yylval.sval=strdup(yytext); return FUNCTION;} -"magnitude" {yylval.sval=strdup(yytext); return FUNCTION;} -"curl" {yylval.sval=strdup(yytext); return FUNCTION;} +#define FLEX_VERSION (YY_FLEX_MAJOR_VERSION * 100 + YY_FLEX_MINOR_VERSION) +// Old versions of Flex (2.5.35) generate an incomplete documentation comment. +// +// In file included from src/scan-code-c.c:3: +// src/scan-code.c:2198:21: error: empty paragraph passed to '@param' command +// [-Werror,-Wdocumentation] +// * @param line_number +// ~~~~~~~~~~~~~~~~~^ +// 1 error generated. +#if FLEX_VERSION < 206 && defined CLANG_VERSION +# pragma clang diagnostic ignored "-Wdocumentation" +#endif -(\.{DIGIT}+)|({DIGIT}+(\.{DIGIT}*)?([eE][+-]?[0-9]+)?) {yylval.dval = atof(yytext); return NUMBER;} +// Old versions of Flex (2.5.35) use 'register'. Warnings introduced in +// GCC 7 and Clang 6. +#if FLEX_VERSION < 206 +# if defined CLANG_VERSION && 600 <= CLANG_VERSION +# pragma clang diagnostic ignored "-Wdeprecated-register" +# elif defined GCC_VERSION && 700 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wregister" +# endif +#endif -[ \t]+ {/* ignore spaces */} +#if FLEX_VERSION < 206 +# if defined CLANG_VERSION +# pragma clang diagnostic ignored "-Wconversion" +# pragma clang diagnostic ignored "-Wdocumentation" +# pragma clang diagnostic ignored "-Wshorten-64-to-32" +# pragma clang diagnostic ignored "-Wsign-conversion" +# elif defined GCC_VERSION +# pragma GCC diagnostic ignored "-Wconversion" +# pragma GCC diagnostic ignored "-Wsign-conversion" +# endif +#endif -(\n|\0|EOF|$end) {return ENDL;} +// Flex 2.6.4, GCC 9 +// warning: useless cast to type 'int' [-Wuseless-cast] +// 1361 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); +// | ^ +#if defined GCC_VERSION && 900 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wuseless-cast" +#endif +%} + +%option noyywrap nounput noinput batch debug + +%{ + // A number symbol corresponding to the value in S. + adios2::detail::parser::symbol_type + make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); +%} -({CHAR}|{DIGIT}|_)+ {yylval.sval=strdup(yytext); return ALIAS;} +op [-+*/^] +var "var" +id [a-zA-Z][a-zA-Z_0-9_]* +path [a-zA-Z][a-zA-Z0-9_\\./-]* +int [0-9]+ +blank [ \t\r] -:(\\|\/|_|{DIGIT})*{CHAR}+(\\|\/|-|_|{DIGIT}|{CHAR})* {yylval.sval=strndup(yytext + 1,strlen(yytext)-1); return PATH;} +%{ + // Code run each time a pattern is matched. + # define YY_USER_ACTION loc.columns (yyleng); +%} +%% +%{ + // A handy shortcut to the location held by the ASTDriver. + adios2::detail::location& loc = drv.location; + // Code run each time yylex is called. + loc.step (); +%} +{blank}+ loc.step (); +\n+ loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); -'(\\|\/|_|{DIGIT})*{CHAR}+(\\|\/|-|_|{DIGIT}|{CHAR})*' {yylval.sval=strndup(yytext + 1,strlen(yytext)-2); return PATH;} +":=" return adios2::detail::parser::make_ASSIGN (loc); +"," return adios2::detail::parser::make_COMMA (loc); +":" return adios2::detail::parser::make_COLON (loc); +"(" return adios2::detail::parser::make_L_PAREN (loc); +")" return adios2::detail::parser::make_R_PAREN (loc); +"[" return adios2::detail::parser::make_L_BRACE (loc); +"]" return adios2::detail::parser::make_R_BRACE (loc); -"["({DIGIT}+|{DIGIT}*":"{DIGIT}*":"{DIGIT}*)(,({DIGIT}+|{DIGIT}*":"{DIGIT}*":"{DIGIT}*))*"]" {yylval.sval=strndup(yytext + 1,strlen(yytext)-2); return INDICES;} +{int} return make_INT (yytext, loc); +{var} return adios2::detail::parser::make_VAR (loc); +{op} return adios2::detail::parser::make_OPERATOR (yytext, loc); +{id} return adios2::detail::parser::make_IDENTIFIER (yytext, loc); +{path} return adios2::detail::parser::make_VARNAME (yytext, loc); +. { + throw adios2::detail::parser::syntax_error + (loc, "invalid character: " + std::string(yytext)); +} +<> return adios2::detail::parser::make_YYEOF (loc); +%% -. {printf("Error at line %d: unrecognized symbol \"%s\"\n", yylloc.first_line, yytext); exit(0);} +adios2::detail::parser::symbol_type +make_INT (const std::string &s, const adios2::detail::parser::location_type& loc) +{ + errno = 0; + long n = strtol (s.c_str(), NULL, 10); + if (! (INT_MIN <= n && n <= INT_MAX && errno != ERANGE)) + throw adios2::detail::parser::syntax_error (loc, "integer is out of range: " + s); + return adios2::detail::parser::make_INT ((int) n, loc); +} -%% \ No newline at end of file +ASTNode* +ASTDriver::parse (const char* input) +{ + adios2::detail::parser parse (*this); + yy_scan_string(input); + parse.set_debug_level (trace_parsing); + parse (); + std::cout << "Parsed input: " << input << std::endl; + return getAST(); +} diff --git a/source/adios2/toolkit/derived/parser/parser.cpp b/source/adios2/toolkit/derived/parser/parser.cpp deleted file mode 100644 index 03938fc8d6..0000000000 --- a/source/adios2/toolkit/derived/parser/parser.cpp +++ /dev/null @@ -1,1666 +0,0 @@ -/* A Bison parser, made by GNU Bison 2.3. */ - -/* Skeleton implementation for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* C LALR(1) parser skeleton written by Richard Stallman, by - simplifying the original so-called "semantic" parser. */ - -/* All symbols defined below should begin with yy or YY, to avoid - infringing on user name space. This should be done even for local - variables, as they might otherwise be expanded by user macros. - There are some unavoidable exceptions within include files to - define necessary library symbols; they are noted "INFRINGES ON - USER NAME SPACE" below. */ - -/* Identify Bison output. */ -#define YYBISON 1 - -/* Bison version. */ -#define YYBISON_VERSION "2.3" - -/* Skeleton name. */ -#define YYSKELETON_NAME "yacc.c" - -/* Pure parsers. */ -#define YYPURE 0 - -/* Using locations. */ -#define YYLSP_NEEDED 1 - -/* Tokens. */ -#ifndef YYTOKENTYPE -#define YYTOKENTYPE -/* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ -enum yytokentype -{ - COMMA = 258, - L_PAREN = 259, - R_PAREN = 260, - ENDL = 261, - FUNCTION = 262, - OPERATOR = 263, - INDICES = 264, - NUMBER = 265, - ALIAS = 266, - PATH = 267 -}; -#endif -/* Tokens. */ -#define COMMA 258 -#define L_PAREN 259 -#define R_PAREN 260 -#define ENDL 261 -#define FUNCTION 262 -#define OPERATOR 263 -#define INDICES 264 -#define NUMBER 265 -#define ALIAS 266 -#define PATH 267 - -/* Copy the first part of user declarations. */ -#line 2 "parser.y" - -#include "parser.h" -#include "lexer.h" -#include -#include -#include -#include -#include -#include - -extern int yyparse(std::stack *expr_stack); - -static void *yyparse_value; - -void yyerror(std::stack *expr_stack, const char *msg); - -namespace adios2 -{ -namespace detail -{ -void *createExpr(std::stack *, std::string, const char *, double, size_t); -} -} - -/* Enabling traces. */ -#ifndef YYDEBUG -#define YYDEBUG 0 -#endif - -/* Enabling verbose error messages. */ -#ifdef YYERROR_VERBOSE -#undef YYERROR_VERBOSE -#define YYERROR_VERBOSE 1 -#else -#define YYERROR_VERBOSE 1 -#endif - -/* Enabling the token table. */ -#ifndef YYTOKEN_TABLE -#define YYTOKEN_TABLE 0 -#endif - -#if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -#line 25 "parser.y" -{ - double dval; - int ival; - char *sval; - void *expr_ptr; -} -/* Line 193 of yacc.c. */ -#line 148 "parser.cpp" -YYSTYPE; -#define yystype YYSTYPE /* obsolescent; will be withdrawn */ -#define YYSTYPE_IS_DECLARED 1 -#define YYSTYPE_IS_TRIVIAL 1 -#endif - -#if !defined YYLTYPE && !defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE -{ - int first_line; - int first_column; - int last_line; - int last_column; -} YYLTYPE; -#define yyltype YYLTYPE /* obsolescent; will be withdrawn */ -#define YYLTYPE_IS_DECLARED 1 -#define YYLTYPE_IS_TRIVIAL 1 -#endif - -/* Copy the second part of user declarations. */ - -/* Line 216 of yacc.c. */ -#line 173 "parser.cpp" - -#ifdef short -#undef short -#endif - -#ifdef YYTYPE_UINT8 -typedef YYTYPE_UINT8 yytype_uint8; -#else -typedef unsigned char yytype_uint8; -#endif - -#ifdef YYTYPE_INT8 -typedef YYTYPE_INT8 yytype_int8; -#elif (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -typedef signed char yytype_int8; -#else -typedef short int yytype_int8; -#endif - -#ifdef YYTYPE_UINT16 -typedef YYTYPE_UINT16 yytype_uint16; -#else -typedef unsigned short int yytype_uint16; -#endif - -#ifdef YYTYPE_INT16 -typedef YYTYPE_INT16 yytype_int16; -#else -typedef short int yytype_int16; -#endif - -#ifndef YYSIZE_T -#ifdef __SIZE_TYPE__ -#define YYSIZE_T __SIZE_TYPE__ -#elif defined size_t -#define YYSIZE_T size_t -#elif !defined YYSIZE_T && \ - (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -#include /* INFRINGES ON USER NAME SPACE */ -#define YYSIZE_T size_t -#else -#define YYSIZE_T unsigned int -#endif -#endif - -#define YYSIZE_MAXIMUM ((YYSIZE_T)-1) - -#ifndef YY_ -#if defined YYENABLE_NLS && YYENABLE_NLS -#if ENABLE_NLS -#include /* INFRINGES ON USER NAME SPACE */ -#define YY_(msgid) dgettext("bison-runtime", msgid) -#endif -#endif -#ifndef YY_ -#define YY_(msgid) msgid -#endif -#endif - -/* Suppress unused-variable warnings by "using" E. */ -#if !defined lint || defined __GNUC__ -#define YYUSE(e) ((void)(e)) -#else -#define YYUSE(e) /* empty */ -#endif - -/* Identity function, used to suppress warnings about constant conditions. */ -#ifndef lint -#define YYID(n) (n) -#else -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static int YYID(int i) -#else -static int YYID(i) -int i; -#endif -{ - return i; -} -#endif - -#if !defined yyoverflow || YYERROR_VERBOSE - -/* The parser invokes alloca or malloc; define the necessary symbols. */ - -#ifdef YYSTACK_USE_ALLOCA -#if YYSTACK_USE_ALLOCA -#ifdef __GNUC__ -#define YYSTACK_ALLOC __builtin_alloca -#elif defined __BUILTIN_VA_ARG_INCR -#include /* INFRINGES ON USER NAME SPACE */ -#elif defined _AIX -#define YYSTACK_ALLOC __alloca -#elif defined _MSC_VER -#include /* INFRINGES ON USER NAME SPACE */ -#define alloca _alloca -#else -#define YYSTACK_ALLOC alloca -#if !defined _ALLOCA_H && !defined _STDLIB_H && \ - (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -#include /* INFRINGES ON USER NAME SPACE */ -#ifndef _STDLIB_H -#define _STDLIB_H 1 -#endif -#endif -#endif -#endif -#endif - -#ifdef YYSTACK_ALLOC -/* Pacify GCC's `empty if-body' warning. */ -#define YYSTACK_FREE(Ptr) \ - do \ - { /* empty */ \ - ; \ - } while (YYID(0)) -#ifndef YYSTACK_ALLOC_MAXIMUM -/* The OS might guarantee only one guard page at the bottom of the stack, - and a page size can be as small as 4096 bytes. So we cannot safely - invoke alloca (N) if N exceeds 4096. Use a slightly smaller number - to allow for a few compiler-allocated temporary stack slots. */ -#define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ -#endif -#else -#define YYSTACK_ALLOC YYMALLOC -#define YYSTACK_FREE YYFREE -#ifndef YYSTACK_ALLOC_MAXIMUM -#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM -#endif -#if (defined __cplusplus && !defined _STDLIB_H && \ - !((defined YYMALLOC || defined malloc) && (defined YYFREE || defined free))) -#include /* INFRINGES ON USER NAME SPACE */ -#ifndef _STDLIB_H -#define _STDLIB_H 1 -#endif -#endif -#ifndef YYMALLOC -#define YYMALLOC malloc -#if !defined malloc && !defined _STDLIB_H && \ - (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -void *malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ -#endif -#endif -#ifndef YYFREE -#define YYFREE free -#if !defined free && !defined _STDLIB_H && \ - (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -void free(void *); /* INFRINGES ON USER NAME SPACE */ -#endif -#endif -#endif -#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ - -#if (!defined yyoverflow && \ - (!defined __cplusplus || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL && \ - defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) - -/* A type that is properly aligned for any stack member. */ -union yyalloc -{ - yytype_int16 yyss; - YYSTYPE yyvs; - YYLTYPE yyls; -}; - -/* The size of the maximum gap between one aligned stack and the next. */ -#define YYSTACK_GAP_MAXIMUM (sizeof(union yyalloc) - 1) - -/* The size of an array large to enough to hold all stacks, each with - N elements. */ -#define YYSTACK_BYTES(N) \ - ((N) * (sizeof(yytype_int16) + sizeof(YYSTYPE) + sizeof(YYLTYPE)) + 2 * YYSTACK_GAP_MAXIMUM) - -/* Copy COUNT objects from FROM to TO. The source and destination do - not overlap. */ -#ifndef YYCOPY -#if defined __GNUC__ && 1 < __GNUC__ -#define YYCOPY(To, From, Count) __builtin_memcpy(To, From, (Count) * sizeof(*(From))) -#else -#define YYCOPY(To, From, Count) \ - do \ - { \ - YYSIZE_T yyi; \ - for (yyi = 0; yyi < (Count); yyi++) \ - (To)[yyi] = (From)[yyi]; \ - } while (YYID(0)) -#endif -#endif - -/* Relocate STACK from its old location to the new one. The - local variables YYSIZE and YYSTACKSIZE give the old and new number of - elements in the stack, and YYPTR gives the new location of the - stack. Advance YYPTR to a properly aligned location for the next - stack. */ -#define YYSTACK_RELOCATE(Stack) \ - do \ - { \ - YYSIZE_T yynewbytes; \ - YYCOPY(&yyptr->Stack, Stack, yysize); \ - Stack = &yyptr->Stack; \ - yynewbytes = yystacksize * sizeof(*Stack) + YYSTACK_GAP_MAXIMUM; \ - yyptr += yynewbytes / sizeof(*yyptr); \ - } while (YYID(0)) - -#endif - -/* YYFINAL -- State number of the termination state. */ -#define YYFINAL 16 -/* YYLAST -- Last index in YYTABLE. */ -#define YYLAST 37 - -/* YYNTOKENS -- Number of terminals. */ -#define YYNTOKENS 13 -/* YYNNTS -- Number of nonterminals. */ -#define YYNNTS 5 -/* YYNRULES -- Number of rules. */ -#define YYNRULES 16 -/* YYNRULES -- Number of states. */ -#define YYNSTATES 28 - -/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ -#define YYUNDEFTOK 2 -#define YYMAXUTOK 267 - -#define YYTRANSLATE(YYX) ((unsigned int)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) - -/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ -static const yytype_uint8 yytranslate[] = { - 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, - 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; - -#if YYDEBUG -/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ -static const yytype_uint8 yyprhs[] = {0, 0, 3, 4, 7, 10, 13, 16, 20, - 24, 26, 28, 31, 33, 35, 39, 43}; - -/* YYRHS -- A `-1'-separated list of the rules' RHS. */ -static const yytype_int8 yyrhs[] = {14, 0, -1, -1, 6, 14, -1, 15, 14, -1, 17, 14, -1, 11, 12, -1, - 11, 12, 9, -1, 16, 3, 17, -1, 17, -1, 11, -1, 11, 9, -1, 12, - -1, 10, -1, 4, 17, 5, -1, 17, 8, 17, -1, 7, 4, 16, 5, -1}; - -/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ -static const yytype_uint8 yyrline[] = {0, 51, 51, 52, 53, 54, 57, 58, 65, - 66, 69, 70, 71, 72, 73, 74, 75}; -#endif - -#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE -/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. - First, the terminals, then, starting at YYNTOKENS, nonterminals. */ -static const char *const yytname[] = {"$end", "error", "$undefined", "COMMA", "L_PAREN", - "R_PAREN", "ENDL", "FUNCTION", "OPERATOR", "INDICES", - "NUMBER", "ALIAS", "PATH", "$accept", "input", - "decl", "list", "exp", 0}; -#endif - -#ifdef YYPRINT -/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to - token YYLEX-NUM. */ -static const yytype_uint16 yytoknum[] = {0, 256, 257, 258, 259, 260, 261, - 262, 263, 264, 265, 266, 267}; -#endif - -/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ -static const yytype_uint8 yyr1[] = {0, 13, 14, 14, 14, 14, 15, 15, 16, - 16, 17, 17, 17, 17, 17, 17, 17}; - -/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ -static const yytype_uint8 yyr2[] = {0, 2, 0, 2, 2, 2, 2, 3, 3, 1, 1, 2, 1, 1, 3, 3, 4}; - -/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state - STATE-NUM when YYTABLE doesn't specify something else to do. Zero - means the default is an error. */ -static const yytype_uint8 yydefact[] = {2, 0, 2, 0, 13, 10, 12, 0, 2, 2, 10, 0, 3, 0, - 11, 6, 1, 4, 0, 5, 14, 0, 9, 7, 15, 0, 16, 8}; - -/* YYDEFGOTO[NTERM-NUM]. */ -static const yytype_int8 yydefgoto[] = {-1, 7, 8, 21, 9}; - -/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ -#define YYPACT_NINF -4 -static const yytype_int8 yypact[] = {9, 18, 9, -2, -4, 2, -4, 6, 9, -3, 1, 26, -4, 18, - -4, 14, -4, -4, 18, -4, -4, 32, 10, -4, 10, 18, -4, 10}; - -/* YYPGOTO[NTERM-NUM]. */ -static const yytype_int8 yypgoto[] = {-4, 24, -4, -4, -1}; - -/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If - positive, shift that token. If negative, reduce the rule which - number is the opposite. If zero, do what YYDEFACT says. - If YYTABLE_NINF, syntax error. */ -#define YYTABLE_NINF -1 -static const yytype_uint8 yytable[] = {11, 1, 13, 2, 3, 18, 16, 4, 5, 6, 14, 14, 22, - 1, 15, 2, 3, 24, 18, 4, 5, 6, 1, 23, 27, 3, - 12, 0, 4, 10, 6, 20, 17, 19, 18, 25, 0, 26}; - -static const yytype_int8 yycheck[] = {1, 4, 4, 6, 7, 8, 0, 10, 11, 12, 9, 9, 13, - 4, 12, 6, 7, 18, 8, 10, 11, 12, 4, 9, 25, 7, - 2, -1, 10, 11, 12, 5, 8, 9, 8, 3, -1, 5}; - -/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ -static const yytype_uint8 yystos[] = {0, 4, 6, 7, 10, 11, 12, 14, 15, 17, 11, 17, 14, 4, - 9, 12, 0, 14, 8, 14, 5, 16, 17, 9, 17, 3, 5, 17}; - -#define yyerrok (yyerrstatus = 0) -#define yyclearin (yychar = YYEMPTY) -#define YYEMPTY (-2) -#define YYEOF 0 - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab - -/* Like YYERROR except do call yyerror. This remains here temporarily - to ease the transition to the new meaning of YYERROR, for GCC. - Once GCC version 2 has supplanted version 1, this can go. */ - -#define YYFAIL goto yyerrlab - -#define YYRECOVERING() (!!yyerrstatus) - -#define YYBACKUP(Token, Value) \ - do \ - if (yychar == YYEMPTY && yylen == 1) \ - { \ - yychar = (Token); \ - yylval = (Value); \ - yytoken = YYTRANSLATE(yychar); \ - YYPOPSTACK(1); \ - goto yybackup; \ - } \ - else \ - { \ - yyerror(expr_stack, YY_("syntax error: cannot back up")); \ - YYERROR; \ - } \ - while (YYID(0)) - -#define YYTERROR 1 -#define YYERRCODE 256 - -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -#define YYRHSLOC(Rhs, K) ((Rhs)[K]) -#ifndef YYLLOC_DEFAULT -#define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (YYID(N)) \ - { \ - (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \ - (Current).first_column = YYRHSLOC(Rhs, 1).first_column; \ - (Current).last_line = YYRHSLOC(Rhs, N).last_line; \ - (Current).last_column = YYRHSLOC(Rhs, N).last_column; \ - } \ - else \ - { \ - (Current).first_line = (Current).last_line = YYRHSLOC(Rhs, 0).last_line; \ - (Current).first_column = (Current).last_column = YYRHSLOC(Rhs, 0).last_column; \ - } \ - while (YYID(0)) -#endif - -/* YY_LOCATION_PRINT -- Print the location on the stream. - This macro was not mandated originally: define only if we know - we won't break user code: when these are the locations we know. */ - -#ifndef YY_LOCATION_PRINT -#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL -#define YY_LOCATION_PRINT(File, Loc) \ - fprintf(File, "%d.%d-%d.%d", (Loc).first_line, (Loc).first_column, (Loc).last_line, \ - (Loc).last_column) -#else -#define YY_LOCATION_PRINT(File, Loc) ((void)0) -#endif -#endif - -/* YYLEX -- calling `yylex' with the right arguments. */ - -#ifdef YYLEX_PARAM -#define YYLEX yylex(YYLEX_PARAM) -#else -#define YYLEX yylex() -#endif - -/* Enable debugging if requested. */ -#if YYDEBUG - -#ifndef YYFPRINTF -#include /* INFRINGES ON USER NAME SPACE */ -#define YYFPRINTF fprintf -#endif - -#define YYDPRINTF(Args) \ - do \ - { \ - if (yydebug) \ - YYFPRINTF Args; \ - } while (YYID(0)) - -#define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ - do \ - { \ - if (yydebug) \ - { \ - YYFPRINTF(stderr, "%s ", Title); \ - yy_symbol_print(stderr, Type, Value, Location, expr_stack); \ - YYFPRINTF(stderr, "\n"); \ - } \ - } while (YYID(0)) - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, - YYLTYPE const *const yylocationp, - std::stack *expr_stack) -#else -static void yy_symbol_value_print(yyoutput, yytype, yyvaluep, yylocationp, - expr_stack) FILE *yyoutput; -int yytype; -YYSTYPE const *const yyvaluep; -YYLTYPE const *const yylocationp; -std::stack *expr_stack; -#endif -{ - if (!yyvaluep) - return; - YYUSE(yylocationp); - YYUSE(expr_stack); -#ifdef YYPRINT - if (yytype < YYNTOKENS) - YYPRINT(yyoutput, yytoknum[yytype], *yyvaluep); -#else - YYUSE(yyoutput); -#endif - switch (yytype) - { - default: - break; - } -} - -/*--------------------------------. -| Print this symbol on YYOUTPUT. | -`--------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep, - YYLTYPE const *const yylocationp, - std::stack *expr_stack) -#else -static void yy_symbol_print(yyoutput, yytype, yyvaluep, yylocationp, expr_stack) FILE *yyoutput; -int yytype; -YYSTYPE const *const yyvaluep; -YYLTYPE const *const yylocationp; -std::stack *expr_stack; -#endif -{ - if (yytype < YYNTOKENS) - YYFPRINTF(yyoutput, "token %s (", yytname[yytype]); - else - YYFPRINTF(yyoutput, "nterm %s (", yytname[yytype]); - - YY_LOCATION_PRINT(yyoutput, *yylocationp); - YYFPRINTF(yyoutput, ": "); - yy_symbol_value_print(yyoutput, yytype, yyvaluep, yylocationp, expr_stack); - YYFPRINTF(yyoutput, ")"); -} - -/*------------------------------------------------------------------. -| yy_stack_print -- Print the state stack from its BOTTOM up to its | -| TOP (included). | -`------------------------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static void yy_stack_print(yytype_int16 *bottom, yytype_int16 *top) -#else -static void yy_stack_print(bottom, top) yytype_int16 *bottom; -yytype_int16 *top; -#endif -{ - YYFPRINTF(stderr, "Stack now"); - for (; bottom <= top; ++bottom) - YYFPRINTF(stderr, " %d", *bottom); - YYFPRINTF(stderr, "\n"); -} - -#define YY_STACK_PRINT(Bottom, Top) \ - do \ - { \ - if (yydebug) \ - yy_stack_print((Bottom), (Top)); \ - } while (YYID(0)) - -/*------------------------------------------------. -| Report that the YYRULE is going to be reduced. | -`------------------------------------------------*/ - -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static void yy_reduce_print(YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, - std::stack *expr_stack) -#else -static void yy_reduce_print(yyvsp, yylsp, yyrule, expr_stack) YYSTYPE *yyvsp; -YYLTYPE *yylsp; -int yyrule; -std::stack *expr_stack; -#endif -{ - int yynrhs = yyr2[yyrule]; - int yyi; - unsigned long int yylno = yyrline[yyrule]; - YYFPRINTF(stderr, "Reducing stack by rule %d (line %lu):\n", yyrule - 1, yylno); - /* The symbols being reduced. */ - for (yyi = 0; yyi < yynrhs; yyi++) - { - fprintf(stderr, " $%d = ", yyi + 1); - yy_symbol_print(stderr, yyrhs[yyprhs[yyrule] + yyi], &(yyvsp[(yyi + 1) - (yynrhs)]), - &(yylsp[(yyi + 1) - (yynrhs)]), expr_stack); - fprintf(stderr, "\n"); - } -} - -#define YY_REDUCE_PRINT(Rule) \ - do \ - { \ - if (yydebug) \ - yy_reduce_print(yyvsp, yylsp, Rule, expr_stack); \ - } while (YYID(0)) - -/* Nonzero means print parse trace. It is left uninitialized so that - multiple parsers can coexist. */ -int yydebug; -#else /* !YYDEBUG */ -#define YYDPRINTF(Args) -#define YY_SYMBOL_PRINT(Title, Type, Value, Location) -#define YY_STACK_PRINT(Bottom, Top) -#define YY_REDUCE_PRINT(Rule) -#endif /* !YYDEBUG */ - -/* YYINITDEPTH -- initial size of the parser's stacks. */ -#ifndef YYINITDEPTH -#define YYINITDEPTH 200 -#endif - -/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only - if the built-in stack extension method is used). - - Do not make this value too large; the results are undefined if - YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) - evaluated with infinite-precision integer arithmetic. */ - -#ifndef YYMAXDEPTH -#define YYMAXDEPTH 10000 -#endif - -#if YYERROR_VERBOSE - -#ifndef yystrlen -#if defined __GLIBC__ && defined _STRING_H -#define yystrlen strlen -#else -/* Return the length of YYSTR. */ -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static YYSIZE_T yystrlen(const char *yystr) -#else -static YYSIZE_T yystrlen(yystr) const char *yystr; -#endif -{ - YYSIZE_T yylen; - for (yylen = 0; yystr[yylen]; yylen++) - continue; - return yylen; -} -#endif -#endif - -#ifndef yystpcpy -#if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE -#define yystpcpy stpcpy -#else -/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in - YYDEST. */ -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static char *yystpcpy(char *yydest, const char *yysrc) -#else -static char *yystpcpy(yydest, yysrc) -char *yydest; -const char *yysrc; -#endif -{ - char *yyd = yydest; - const char *yys = yysrc; - - while ((*yyd++ = *yys++) != '\0') - continue; - - return yyd - 1; -} -#endif -#endif - -#ifndef yytnamerr -/* Copy to YYRES the contents of YYSTR after stripping away unnecessary - quotes and backslashes, so that it's suitable for yyerror. The - heuristic is that double-quoting is unnecessary unless the string - contains an apostrophe, a comma, or backslash (other than - backslash-backslash). YYSTR is taken from yytname. If YYRES is - null, do not copy; instead, return the length of what the result - would have been. */ -static YYSIZE_T yytnamerr(char *yyres, const char *yystr) -{ - if (*yystr == '"') - { - YYSIZE_T yyn = 0; - char const *yyp = yystr; - - for (;;) - switch (*++yyp) - { - case '\'': - case ',': - goto do_not_strip_quotes; - - case '\\': - if (*++yyp != '\\') - goto do_not_strip_quotes; - /* Fall through. */ - default: - if (yyres) - yyres[yyn] = *yyp; - yyn++; - break; - - case '"': - if (yyres) - yyres[yyn] = '\0'; - return yyn; - } - do_not_strip_quotes:; - } - - if (!yyres) - return yystrlen(yystr); - - return yystpcpy(yyres, yystr) - yyres; -} -#endif - -/* Copy into YYRESULT an error message about the unexpected token - YYCHAR while in state YYSTATE. Return the number of bytes copied, - including the terminating null byte. If YYRESULT is null, do not - copy anything; just return the number of bytes that would be - copied. As a special case, return 0 if an ordinary "syntax error" - message will do. Return YYSIZE_MAXIMUM if overflow occurs during - size calculation. */ -static YYSIZE_T yysyntax_error(char *yyresult, int yystate, int yychar) -{ - int yyn = yypact[yystate]; - - if (!(YYPACT_NINF < yyn && yyn <= YYLAST)) - return 0; - else - { - int yytype = YYTRANSLATE(yychar); - YYSIZE_T yysize0 = yytnamerr(0, yytname[yytype]); - YYSIZE_T yysize = yysize0; - YYSIZE_T yysize1; - int yysize_overflow = 0; - enum - { - YYERROR_VERBOSE_ARGS_MAXIMUM = 5 - }; - char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; - int yyx; - -#if 0 - /* This is so xgettext sees the translatable formats that are - constructed on the fly. */ - YY_("syntax error, unexpected %s"); - YY_("syntax error, unexpected %s, expecting %s"); - YY_("syntax error, unexpected %s, expecting %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s"); - YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); -#endif - char *yyfmt; - char const *yyf; - static char const yyunexpected[] = "syntax error, unexpected %s"; - static char const yyexpecting[] = ", expecting %s"; - static char const yyor[] = " or %s"; - char yyformat[sizeof yyunexpected + sizeof yyexpecting - 1 + - ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) * (sizeof yyor - 1))]; - char const *yyprefix = yyexpecting; - - /* Start YYX at -YYN if negative to avoid negative indexes in - YYCHECK. */ - int yyxbegin = yyn < 0 ? -yyn : 0; - - /* Stay within bounds of both yycheck and yytname. */ - int yychecklim = YYLAST - yyn + 1; - int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; - int yycount = 1; - - yyarg[0] = yytname[yytype]; - yyfmt = yystpcpy(yyformat, yyunexpected); - - for (yyx = yyxbegin; yyx < yyxend; ++yyx) - if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) - { - if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) - { - yycount = 1; - yysize = yysize0; - yyformat[sizeof yyunexpected - 1] = '\0'; - break; - } - yyarg[yycount++] = yytname[yyx]; - yysize1 = yysize + yytnamerr(0, yytname[yyx]); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - yyfmt = yystpcpy(yyfmt, yyprefix); - yyprefix = yyor; - } - - yyf = YY_(yyformat); - yysize1 = yysize + yystrlen(yyf); - yysize_overflow |= (yysize1 < yysize); - yysize = yysize1; - - if (yysize_overflow) - return YYSIZE_MAXIMUM; - - if (yyresult) - { - /* Avoid sprintf, as that infringes on the user's name space. - Don't have undefined behavior even if the translation - produced a string with the wrong number of "%s"s. */ - char *yyp = yyresult; - int yyi = 0; - while ((*yyp = *yyf) != '\0') - { - if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) - { - yyp += yytnamerr(yyp, yyarg[yyi++]); - yyf += 2; - } - else - { - yyp++; - yyf++; - } - } - } - return yysize; - } -} -#endif /* YYERROR_VERBOSE */ - -/*-----------------------------------------------. -| Release the memory associated to this symbol. | -`-----------------------------------------------*/ - -/*ARGSUSED*/ -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, - std::stack *expr_stack) -#else -static void yydestruct(yymsg, yytype, yyvaluep, yylocationp, expr_stack) const char *yymsg; -int yytype; -YYSTYPE *yyvaluep; -YYLTYPE *yylocationp; -std::stack *expr_stack; -#endif -{ - YYUSE(yyvaluep); - YYUSE(yylocationp); - YYUSE(expr_stack); - - if (!yymsg) - yymsg = "Deleting"; - YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp); - - switch (yytype) - { - - default: - break; - } -} - -/* Prevent warnings from -Wmissing-prototypes. */ - -#ifdef YYPARSE_PARAM -#if defined __STDC__ || defined __cplusplus -int yyparse(void *YYPARSE_PARAM); -#else -int yyparse(); -#endif -#else /* ! YYPARSE_PARAM */ -#if defined __STDC__ || defined __cplusplus -int yyparse(std::stack *expr_stack); -#else -int yyparse(); -#endif -#endif /* ! YYPARSE_PARAM */ - -/* The look-ahead symbol. */ -int yychar; - -/* The semantic value of the look-ahead symbol. */ -YYSTYPE yylval; - -/* Number of syntax errors so far. */ -int yynerrs; -/* Location data for the look-ahead symbol. */ -YYLTYPE yylloc; - -/*----------. -| yyparse. | -`----------*/ - -#ifdef YYPARSE_PARAM -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -int yyparse(void *YYPARSE_PARAM) -#else -int yyparse(YYPARSE_PARAM) void *YYPARSE_PARAM; -#endif -#else /* ! YYPARSE_PARAM */ -#if (defined __STDC__ || defined __C99__FUNC__ || defined __cplusplus || defined _MSC_VER) -int yyparse(std::stack *expr_stack) -#else -int yyparse(expr_stack) std::stack *expr_stack; -#endif -#endif -{ - - int yystate; - int yyn; - int yyresult; - /* Number of tokens to shift before error messages enabled. */ - int yyerrstatus; - /* Look-ahead token as an internal (translated) token number. */ - int yytoken = 0; -#if YYERROR_VERBOSE - /* Buffer for error messages, and its allocated size. */ - char yymsgbuf[128]; - char *yymsg = yymsgbuf; - YYSIZE_T yymsg_alloc = sizeof yymsgbuf; -#endif - - /* Three stacks and their tools: - `yyss': related to states, - `yyvs': related to semantic values, - `yyls': related to locations. - - Refer to the stacks thru separate pointers, to allow yyoverflow - to reallocate them elsewhere. */ - - /* The state stack. */ - yytype_int16 yyssa[YYINITDEPTH]; - yytype_int16 *yyss = yyssa; - yytype_int16 *yyssp; - - /* The semantic value stack. */ - YYSTYPE yyvsa[YYINITDEPTH]; - YYSTYPE *yyvs = yyvsa; - YYSTYPE *yyvsp; - - /* The location stack. */ - YYLTYPE yylsa[YYINITDEPTH]; - YYLTYPE *yyls = yylsa; - YYLTYPE *yylsp; - /* The locations where the error started and ended. */ - YYLTYPE yyerror_range[2]; - -#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N)) - - YYSIZE_T yystacksize = YYINITDEPTH; - - /* The variables used to return semantic value and location from the - action routines. */ - YYSTYPE yyval; - YYLTYPE yyloc; - - /* The number of symbols on the RHS of the reduced rule. - Keep to zero when no symbol should be popped. */ - int yylen = 0; - - YYDPRINTF((stderr, "Starting parse\n")); - - yystate = 0; - yyerrstatus = 0; - yynerrs = 0; - yychar = YYEMPTY; /* Cause a token to be read. */ - - /* Initialize stack pointers. - Waste one element of value and location stack - so that they stay on the same level as the state stack. - The wasted elements are never initialized. */ - - yyssp = yyss; - yyvsp = yyvs; - yylsp = yyls; -#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL - /* Initialize the default location before parsing starts. */ - yylloc.first_line = yylloc.last_line = 1; - yylloc.first_column = yylloc.last_column = 0; -#endif - - goto yysetstate; - - /*------------------------------------------------------------. - | yynewstate -- Push a new state, which is found in yystate. | - `------------------------------------------------------------*/ -yynewstate: - /* In all cases, when you get here, the value and location stacks - have just been pushed. So pushing a state here evens the stacks. */ - yyssp++; - -yysetstate: - *yyssp = yystate; - - if (yyss + yystacksize - 1 <= yyssp) - { - /* Get the current used size of the three stacks, in elements. */ - YYSIZE_T yysize = yyssp - yyss + 1; - -#ifdef yyoverflow - { - /* Give user a chance to reallocate the stack. Use copies of - these so that the &'s don't force the real ones into - memory. */ - YYSTYPE *yyvs1 = yyvs; - yytype_int16 *yyss1 = yyss; - YYLTYPE *yyls1 = yyls; - - /* Each stack pointer address is followed by the size of the - data in use in that stack, in bytes. This used to be a - conditional around just the two extra args, but that might - be undefined if yyoverflow is a macro. */ - yyoverflow(YY_("memory exhausted"), &yyss1, yysize * sizeof(*yyssp), &yyvs1, - yysize * sizeof(*yyvsp), &yyls1, yysize * sizeof(*yylsp), &yystacksize); - yyls = yyls1; - yyss = yyss1; - yyvs = yyvs1; - } -#else /* no yyoverflow */ -#ifndef YYSTACK_RELOCATE - goto yyexhaustedlab; -#else - /* Extend the stack our own way. */ - if (YYMAXDEPTH <= yystacksize) - goto yyexhaustedlab; - yystacksize *= 2; - if (YYMAXDEPTH < yystacksize) - yystacksize = YYMAXDEPTH; - - { - yytype_int16 *yyss1 = yyss; - union yyalloc *yyptr = (union yyalloc *)YYSTACK_ALLOC(YYSTACK_BYTES(yystacksize)); - if (!yyptr) - goto yyexhaustedlab; - YYSTACK_RELOCATE(yyss); - YYSTACK_RELOCATE(yyvs); - YYSTACK_RELOCATE(yyls); -#undef YYSTACK_RELOCATE - if (yyss1 != yyssa) - YYSTACK_FREE(yyss1); - } -#endif -#endif /* no yyoverflow */ - - yyssp = yyss + yysize - 1; - yyvsp = yyvs + yysize - 1; - yylsp = yyls + yysize - 1; - - YYDPRINTF((stderr, "Stack size increased to %lu\n", (unsigned long int)yystacksize)); - - if (yyss + yystacksize - 1 <= yyssp) - YYABORT; - } - - YYDPRINTF((stderr, "Entering state %d\n", yystate)); - - goto yybackup; - -/*-----------. -| yybackup. | -`-----------*/ -yybackup: - - /* Do appropriate processing given the current state. Read a - look-ahead token if we need one and don't already have one. */ - - /* First try to decide what to do without reference to look-ahead token. */ - yyn = yypact[yystate]; - if (yyn == YYPACT_NINF) - goto yydefault; - - /* Not known => get a look-ahead token if don't already have one. */ - - /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ - if (yychar == YYEMPTY) - { - YYDPRINTF((stderr, "Reading a token: ")); - yychar = YYLEX; - } - - if (yychar <= YYEOF) - { - yychar = yytoken = YYEOF; - YYDPRINTF((stderr, "Now at end of input.\n")); - } - else - { - yytoken = YYTRANSLATE(yychar); - YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc); - } - - /* If the proper action on seeing token YYTOKEN is to reduce or to - detect an error, take that action. */ - yyn += yytoken; - if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) - goto yydefault; - yyn = yytable[yyn]; - if (yyn <= 0) - { - if (yyn == 0 || yyn == YYTABLE_NINF) - goto yyerrlab; - yyn = -yyn; - goto yyreduce; - } - - if (yyn == YYFINAL) - YYACCEPT; - - /* Count tokens shifted since error; after three, turn off error - status. */ - if (yyerrstatus) - yyerrstatus--; - - /* Shift the look-ahead token. */ - YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc); - - /* Discard the shifted token unless it is eof. */ - if (yychar != YYEOF) - yychar = YYEMPTY; - - yystate = yyn; - *++yyvsp = yylval; - *++yylsp = yylloc; - goto yynewstate; - -/*-----------------------------------------------------------. -| yydefault -- do the default action for the current state. | -`-----------------------------------------------------------*/ -yydefault: - yyn = yydefact[yystate]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - -/*-----------------------------. -| yyreduce -- Do a reduction. | -`-----------------------------*/ -yyreduce: - /* yyn is the number of a rule to reduce with. */ - yylen = yyr2[yyn]; - - /* If YYLEN is nonzero, implement the default value of the action: - `$$ = $1'. - - Otherwise, the following line sets YYVAL to garbage. - This behavior is undocumented and Bison - users should not rely upon it. Assigning to YYVAL - unconditionally makes the parser a bit smaller, and it avoids a - GCC warning that YYVAL may be used uninitialized. */ - yyval = yyvsp[1 - yylen]; - - /* Default location. */ - YYLLOC_DEFAULT(yyloc, (yylsp - yylen), yylen); - YY_REDUCE_PRINT(yyn); - switch (yyn) - { - case 2: -#line 51 "parser.y" - { - ; - } - break; - - case 3: -#line 52 "parser.y" - { - ; - } - break; - - case 4: -#line 53 "parser.y" - { - ; - } - break; - - case 5: -#line 54 "parser.y" - { /*yyparse_value = $1->expression;*/ - ; - } - break; - - case 6: -#line 57 "parser.y" - { - adios2::detail::ASTNode::add_lookup_entry((yyvsp[(1) - (2)].sval), (yyvsp[(2) - (2)].sval), - ""); - ; - } - break; - - case 7: -#line 58 "parser.y" - { - adios2::detail::ASTNode::add_lookup_entry((yyvsp[(1) - (3)].sval), (yyvsp[(2) - (3)].sval), - (yyvsp[(3) - (3)].sval)); - ; - } - break; - - case 8: -#line 65 "parser.y" - { - (yyval.ival) = (yyvsp[(1) - (3)].ival) + 1; - ; - } - break; - - case 9: -#line 66 "parser.y" - { - (yyval.ival) = 1; - ; - } - break; - - case 10: -#line 69 "parser.y" - { - (yyval.expr_ptr) = createExpr(expr_stack, "ALIAS", (yyvsp[(1) - (1)].sval), 0, 0); - ; - } - break; - - case 11: -#line 70 "parser.y" - { - createExpr(expr_stack, "ALIAS", (yyvsp[(1) - (2)].sval), 0, 0); - (yyval.expr_ptr) = createExpr(expr_stack, "INDEX", (yyvsp[(2) - (2)].sval), 0, 1); - ; - } - break; - - case 12: -#line 71 "parser.y" - { - (yyval.expr_ptr) = createExpr(expr_stack, "PATH", (yyvsp[(1) - (1)].sval), 0, 0); - ; - } - break; - - case 13: -#line 72 "parser.y" - { - (yyval.expr_ptr) = createExpr(expr_stack, "NUM", "", (yyvsp[(1) - (1)].dval), 0); - ; - } - break; - - case 14: -#line 73 "parser.y" - { - (yyval.expr_ptr) = (yyvsp[(2) - (3)].expr_ptr); - ; - } - break; - - case 15: -#line 74 "parser.y" - { - (yyval.expr_ptr) = createExpr(expr_stack, (yyvsp[(2) - (3)].sval), "", 0, 2); - ; - } - break; - - case 16: -#line 75 "parser.y" - { - (yyval.expr_ptr) = - createExpr(expr_stack, (yyvsp[(1) - (4)].sval), "", 0, (yyvsp[(3) - (4)].ival)); - ; - } - break; - -/* Line 1267 of yacc.c. */ -#line 1480 "parser.cpp" - default: - break; - } - YY_SYMBOL_PRINT("-> $$ =", yyr1[yyn], &yyval, &yyloc); - - YYPOPSTACK(yylen); - yylen = 0; - YY_STACK_PRINT(yyss, yyssp); - - *++yyvsp = yyval; - *++yylsp = yyloc; - - /* Now `shift' the result of the reduction. Determine what state - that goes to, based on the state we popped back to and the rule - number reduced by. */ - - yyn = yyr1[yyn]; - - yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; - if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) - yystate = yytable[yystate]; - else - yystate = yydefgoto[yyn - YYNTOKENS]; - - goto yynewstate; - -/*------------------------------------. -| yyerrlab -- here on detecting error | -`------------------------------------*/ -yyerrlab: - /* If not already recovering from an error, report this error. */ - if (!yyerrstatus) - { - ++yynerrs; -#if !YYERROR_VERBOSE - yyerror(expr_stack, YY_("syntax error")); -#else - { - YYSIZE_T yysize = yysyntax_error(0, yystate, yychar); - if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) - { - YYSIZE_T yyalloc = 2 * yysize; - if (!(yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) - yyalloc = YYSTACK_ALLOC_MAXIMUM; - if (yymsg != yymsgbuf) - YYSTACK_FREE(yymsg); - yymsg = (char *)YYSTACK_ALLOC(yyalloc); - if (yymsg) - yymsg_alloc = yyalloc; - else - { - yymsg = yymsgbuf; - yymsg_alloc = sizeof yymsgbuf; - } - } - - if (0 < yysize && yysize <= yymsg_alloc) - { - (void)yysyntax_error(yymsg, yystate, yychar); - yyerror(expr_stack, yymsg); - } - else - { - yyerror(expr_stack, YY_("syntax error")); - if (yysize != 0) - goto yyexhaustedlab; - } - } -#endif - } - - yyerror_range[0] = yylloc; - - if (yyerrstatus == 3) - { - /* If just tried and failed to reuse look-ahead token after an - error, discard it. */ - - if (yychar <= YYEOF) - { - /* Return failure if at end of input. */ - if (yychar == YYEOF) - YYABORT; - } - else - { - yydestruct("Error: discarding", yytoken, &yylval, &yylloc, expr_stack); - yychar = YYEMPTY; - } - } - - /* Else will try to reuse look-ahead token after shifting the error - token. */ - goto yyerrlab1; - -/*---------------------------------------------------. -| yyerrorlab -- error raised explicitly by YYERROR. | -`---------------------------------------------------*/ -yyerrorlab: - - /* Pacify compilers like GCC when the user code never invokes - YYERROR and the label yyerrorlab therefore never appears in user - code. */ - if (/*CONSTCOND*/ 0) - goto yyerrorlab; - - yyerror_range[0] = yylsp[1 - yylen]; - /* Do not reclaim the symbols of the rule which action triggered - this YYERROR. */ - YYPOPSTACK(yylen); - yylen = 0; - YY_STACK_PRINT(yyss, yyssp); - yystate = *yyssp; - goto yyerrlab1; - -/*-------------------------------------------------------------. -| yyerrlab1 -- common code for both syntax error and YYERROR. | -`-------------------------------------------------------------*/ -yyerrlab1: - yyerrstatus = 3; /* Each real token shifted decrements this. */ - - for (;;) - { - yyn = yypact[yystate]; - if (yyn != YYPACT_NINF) - { - yyn += YYTERROR; - if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) - { - yyn = yytable[yyn]; - if (0 < yyn) - break; - } - } - - /* Pop the current state because it cannot handle the error token. */ - if (yyssp == yyss) - YYABORT; - - yyerror_range[0] = *yylsp; - yydestruct("Error: popping", yystos[yystate], yyvsp, yylsp, expr_stack); - YYPOPSTACK(1); - yystate = *yyssp; - YY_STACK_PRINT(yyss, yyssp); - } - - if (yyn == YYFINAL) - YYACCEPT; - - *++yyvsp = yylval; - - yyerror_range[1] = yylloc; - /* Using YYLLOC is tempting, but would change the location of - the look-ahead. YYLOC is available though. */ - YYLLOC_DEFAULT(yyloc, (yyerror_range - 1), 2); - *++yylsp = yyloc; - - /* Shift the error token. */ - YY_SYMBOL_PRINT("Shifting", yystos[yyn], yyvsp, yylsp); - - yystate = yyn; - goto yynewstate; - -/*-------------------------------------. -| yyacceptlab -- YYACCEPT comes here. | -`-------------------------------------*/ -yyacceptlab: - yyresult = 0; - goto yyreturn; - -/*-----------------------------------. -| yyabortlab -- YYABORT comes here. | -`-----------------------------------*/ -yyabortlab: - yyresult = 1; - goto yyreturn; - -#ifndef yyoverflow -/*-------------------------------------------------. -| yyexhaustedlab -- memory exhaustion comes here. | -`-------------------------------------------------*/ -yyexhaustedlab: - yyerror(expr_stack, YY_("memory exhausted")); - yyresult = 2; - /* Fall through. */ -#endif - -yyreturn: - if (yychar != YYEOF && yychar != YYEMPTY) - yydestruct("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc, expr_stack); - /* Do not reclaim the symbols of the rule which action triggered - this YYABORT or YYACCEPT. */ - YYPOPSTACK(yylen); - YY_STACK_PRINT(yyss, yyssp); - while (yyssp != yyss) - { - yydestruct("Cleanup: popping", yystos[*yyssp], yyvsp, yylsp, expr_stack); - YYPOPSTACK(1); - } -#ifndef yyoverflow - if (yyss != yyssa) - YYSTACK_FREE(yyss); -#endif -#if YYERROR_VERBOSE - if (yymsg != yymsgbuf) - YYSTACK_FREE(yymsg); -#endif - /* Make sure YYID is used. */ - return YYID(yyresult); -} - -#line 77 "parser.y" - -namespace adios2 -{ -namespace detail -{ - -void *createExpr(std::stack *expr_stack, std::string str_op, const char *name, - double value, size_t numsubexprs) -{ - // std::cout << "Creating ASTNode in function createExpr" << std::endl; - // std::cout << "\tstack size: " << expr_stack->size() << "\n\top: " << str_op << "\n\tname: " - // << name << "\n\tvalue: " << value << "\n\tnumsubexprs: " << numsubexprs << std::endl; - - ExpressionOperator op = get_op(str_op); - - ASTNode *node = new ASTNode(op); - switch (op) - { - case ExpressionOperator::OP_ALIAS: - node = new ASTNode(op, name); - break; - case ExpressionOperator::OP_PATH: - node = new ASTNode(op, name); - break; - case ExpressionOperator::OP_NUM: - node = new ASTNode(op, value); - break; - case ExpressionOperator::OP_INDEX: - // TODO: translate indices - node = new ASTNode(op, name); - break; - default: - node = new ASTNode(op); - }; - node->extend_subexprs(numsubexprs); - for (size_t i = 1; i <= numsubexprs; ++i) - { - ASTNode *subexpr = expr_stack->top(); - node->add_back_subexpr(subexpr, i); - expr_stack->pop(); - } - expr_stack->push(node); - - return &expr_stack->top(); -} - -ASTNode *parse_expression(std::string input) -{ - yy_scan_string(input.c_str()); - std::stack expr_stack; - yyparse(&expr_stack); - - // DEBUGGING - // std::cout << "yyparse complete. Stack size: " << expr_stack.size() << std::endl; - // std::cout << "parser prettyprint:" << std::endl; - // expr_stack.top()->printpretty(""); - return expr_stack.top(); -} - -} -} - -void yyerror(std::stack *expr_stack, const char *msg) -{ - printf("** Line %d: %s\n", yylloc.first_line, msg); -} diff --git a/source/adios2/toolkit/derived/parser/parser.h b/source/adios2/toolkit/derived/parser/parser.h deleted file mode 100644 index 38c3c96d58..0000000000 --- a/source/adios2/toolkit/derived/parser/parser.h +++ /dev/null @@ -1,110 +0,0 @@ -/* A Bison parser, made by GNU Bison 2.3. */ - -/* Skeleton interface for Bison's Yacc-like parsers in C - - Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 - Free Software Foundation, Inc. - - This program is free software; you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) - any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, - Boston, MA 02110-1301, USA. */ - -/* As a special exception, you may create a larger work that contains - part or all of the Bison parser skeleton and distribute that work - under terms of your choice, so long as that work isn't itself a - parser generator using the skeleton or a modified version thereof - as a parser skeleton. Alternatively, if you modify or redistribute - the parser skeleton itself, you may (at your option) remove this - special exception, which will cause the skeleton and the resulting - Bison output files to be licensed under the GNU General Public - License without this special exception. - - This special exception was added by the Free Software Foundation in - version 2.2 of Bison. */ - -/* Tokens. */ -#ifndef YYTOKENTYPE -#define YYTOKENTYPE -/* Put the tokens into the symbol table, so that GDB and other debuggers - know about them. */ -enum yytokentype -{ - COMMA = 258, - L_PAREN = 259, - R_PAREN = 260, - ENDL = 261, - FUNCTION = 262, - OPERATOR = 263, - INDICES = 264, - NUMBER = 265, - ALIAS = 266, - PATH = 267 -}; -#endif -/* Tokens. */ -#define COMMA 258 -#define L_PAREN 259 -#define R_PAREN 260 -#define ENDL 261 -#define FUNCTION 262 -#define OPERATOR 263 -#define INDICES 264 -#define NUMBER 265 -#define ALIAS 266 -#define PATH 267 - -#if !defined YYSTYPE && !defined YYSTYPE_IS_DECLARED -typedef union YYSTYPE -#line 25 "parser.y" -{ - double dval; - int ival; - char *sval; - void *expr_ptr; -} -/* Line 1529 of yacc.c. */ -#line 80 "parser.h" -YYSTYPE; -#define yystype YYSTYPE /* obsolescent; will be withdrawn */ -#define YYSTYPE_IS_DECLARED 1 -#define YYSTYPE_IS_TRIVIAL 1 -#endif - -extern YYSTYPE yylval; - -#if !defined YYLTYPE && !defined YYLTYPE_IS_DECLARED -typedef struct YYLTYPE -{ - int first_line; - int first_column; - int last_line; - int last_column; -} YYLTYPE; -#define yyltype YYLTYPE /* obsolescent; will be withdrawn */ -#define YYLTYPE_IS_DECLARED 1 -#define YYLTYPE_IS_TRIVIAL 1 -#endif - -extern YYLTYPE yylloc; - -#include "ASTNode.h" -#include - -namespace adios2 -{ -namespace detail -{ -ASTNode *parse_expression(std::string input); -} -} diff --git a/source/adios2/toolkit/derived/parser/parser.output b/source/adios2/toolkit/derived/parser/parser.output deleted file mode 100644 index ae7a9b24a1..0000000000 --- a/source/adios2/toolkit/derived/parser/parser.output +++ /dev/null @@ -1,350 +0,0 @@ -State 5 conflicts: 1 shift/reduce -State 24 conflicts: 1 shift/reduce - - -Grammar - - 0 $accept: input $end - - 1 input: /* empty */ - 2 | ENDL input - 3 | decl input - 4 | exp input - - 5 decl: ALIAS PATH - 6 | ALIAS PATH INDICES - - 7 list: list COMMA exp - 8 | exp - - 9 exp: ALIAS - 10 | ALIAS INDICES - 11 | PATH - 12 | NUMBER - 13 | L_PAREN exp R_PAREN - 14 | exp OPERATOR exp - 15 | FUNCTION L_PAREN list R_PAREN - - -Terminals, with rules where they appear - -$end (0) 0 -error (256) -COMMA (258) 7 -L_PAREN (259) 13 15 -R_PAREN (260) 13 15 -ENDL (261) 2 -FUNCTION (262) 15 -OPERATOR (263) 14 -INDICES (264) 6 10 -NUMBER (265) 12 -ALIAS (266) 5 6 9 10 -PATH (267) 5 6 11 - - -Nonterminals, with rules where they appear - -$accept (13) - on left: 0 -input (14) - on left: 1 2 3 4, on right: 0 2 3 4 -decl (15) - on left: 5 6, on right: 3 -list (16) - on left: 7 8, on right: 7 15 -exp (17) - on left: 9 10 11 12 13 14 15, on right: 4 7 8 13 14 - - -state 0 - - 0 $accept: . input $end - - L_PAREN shift, and go to state 1 - ENDL shift, and go to state 2 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 5 - PATH shift, and go to state 6 - - $default reduce using rule 1 (input) - - input go to state 7 - decl go to state 8 - exp go to state 9 - - -state 1 - - 13 exp: L_PAREN . exp R_PAREN - - L_PAREN shift, and go to state 1 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 10 - PATH shift, and go to state 6 - - exp go to state 11 - - -state 2 - - 2 input: ENDL . input - - L_PAREN shift, and go to state 1 - ENDL shift, and go to state 2 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 5 - PATH shift, and go to state 6 - - $default reduce using rule 1 (input) - - input go to state 12 - decl go to state 8 - exp go to state 9 - - -state 3 - - 15 exp: FUNCTION . L_PAREN list R_PAREN - - L_PAREN shift, and go to state 13 - - -state 4 - - 12 exp: NUMBER . - - $default reduce using rule 12 (exp) - - -state 5 - - 5 decl: ALIAS . PATH - 6 | ALIAS . PATH INDICES - 9 exp: ALIAS . - 10 | ALIAS . INDICES - - INDICES shift, and go to state 14 - PATH shift, and go to state 15 - - PATH [reduce using rule 9 (exp)] - $default reduce using rule 9 (exp) - - -state 6 - - 11 exp: PATH . - - $default reduce using rule 11 (exp) - - -state 7 - - 0 $accept: input . $end - - $end shift, and go to state 16 - - -state 8 - - 3 input: decl . input - - L_PAREN shift, and go to state 1 - ENDL shift, and go to state 2 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 5 - PATH shift, and go to state 6 - - $default reduce using rule 1 (input) - - input go to state 17 - decl go to state 8 - exp go to state 9 - - -state 9 - - 4 input: exp . input - 14 exp: exp . OPERATOR exp - - L_PAREN shift, and go to state 1 - ENDL shift, and go to state 2 - FUNCTION shift, and go to state 3 - OPERATOR shift, and go to state 18 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 5 - PATH shift, and go to state 6 - - $default reduce using rule 1 (input) - - input go to state 19 - decl go to state 8 - exp go to state 9 - - -state 10 - - 9 exp: ALIAS . - 10 | ALIAS . INDICES - - INDICES shift, and go to state 14 - - $default reduce using rule 9 (exp) - - -state 11 - - 13 exp: L_PAREN exp . R_PAREN - 14 | exp . OPERATOR exp - - R_PAREN shift, and go to state 20 - OPERATOR shift, and go to state 18 - - -state 12 - - 2 input: ENDL input . - - $default reduce using rule 2 (input) - - -state 13 - - 15 exp: FUNCTION L_PAREN . list R_PAREN - - L_PAREN shift, and go to state 1 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 10 - PATH shift, and go to state 6 - - list go to state 21 - exp go to state 22 - - -state 14 - - 10 exp: ALIAS INDICES . - - $default reduce using rule 10 (exp) - - -state 15 - - 5 decl: ALIAS PATH . - 6 | ALIAS PATH . INDICES - - INDICES shift, and go to state 23 - - $default reduce using rule 5 (decl) - - -state 16 - - 0 $accept: input $end . - - $default accept - - -state 17 - - 3 input: decl input . - - $default reduce using rule 3 (input) - - -state 18 - - 14 exp: exp OPERATOR . exp - - L_PAREN shift, and go to state 1 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 10 - PATH shift, and go to state 6 - - exp go to state 24 - - -state 19 - - 4 input: exp input . - - $default reduce using rule 4 (input) - - -state 20 - - 13 exp: L_PAREN exp R_PAREN . - - $default reduce using rule 13 (exp) - - -state 21 - - 7 list: list . COMMA exp - 15 exp: FUNCTION L_PAREN list . R_PAREN - - COMMA shift, and go to state 25 - R_PAREN shift, and go to state 26 - - -state 22 - - 8 list: exp . - 14 exp: exp . OPERATOR exp - - OPERATOR shift, and go to state 18 - - $default reduce using rule 8 (list) - - -state 23 - - 6 decl: ALIAS PATH INDICES . - - $default reduce using rule 6 (decl) - - -state 24 - - 14 exp: exp . OPERATOR exp - 14 | exp OPERATOR exp . - - OPERATOR shift, and go to state 18 - - OPERATOR [reduce using rule 14 (exp)] - $default reduce using rule 14 (exp) - - -state 25 - - 7 list: list COMMA . exp - - L_PAREN shift, and go to state 1 - FUNCTION shift, and go to state 3 - NUMBER shift, and go to state 4 - ALIAS shift, and go to state 10 - PATH shift, and go to state 6 - - exp go to state 27 - - -state 26 - - 15 exp: FUNCTION L_PAREN list R_PAREN . - - $default reduce using rule 15 (exp) - - -state 27 - - 7 list: list COMMA exp . - 14 exp: exp . OPERATOR exp - - OPERATOR shift, and go to state 18 - - $default reduce using rule 7 (list) \ No newline at end of file diff --git a/source/adios2/toolkit/derived/parser/parser.y b/source/adios2/toolkit/derived/parser/parser.y index d9bf172459..f72cb11a36 100644 --- a/source/adios2/toolkit/derived/parser/parser.y +++ b/source/adios2/toolkit/derived/parser/parser.y @@ -1,132 +1,116 @@ -/* calculator. */ -%{ - #include - #include - #include - #include - #include - #include - #include - #include "lexer.h" - #include "ASTNode.h" - - extern int yyparse(std::stack* expr_stack); - - void* createExpr(std::stack*, std::string, const char*, double, size_t); - - static void* yyparse_value; - - void yyerror(std::stack* expr_stack, const char *msg); - -%} - -%parse-param {std::stack* expr_stack} - -%union{ - double dval; - int ival; - char* sval; - void* expr_ptr; +%skeleton "lalr1.cc" // -*- C++ -*- +%require "3.8.2" +%header + +%define api.token.raw +%define api.namespace {adios2::detail} +%define api.token.constructor +%define api.value.type variant +%define parse.assert + +%code requires { + #include + #include + #include + class ASTDriver; } -%error-verbose +// The parsing context. +%param { ASTDriver& drv } + %locations -%start input -%token COMMA L_PAREN R_PAREN ENDL -%token FUNCTION -%token OPERATOR -%token INDICES -%token NUMBER -%token ALIAS PATH -%type NUMBER -%type ALIAS PATH INDICES -%type FUNCTION OPERATOR -%type input exp -%type list - - -%% - -input: {} - | ENDL input {} - | decl input {} - | exp input { /*yyparse_value = $1->expression;*/ } - ; - -decl: ALIAS PATH { ASTNode::add_lookup_entry($1, $2, ""); } - | ALIAS PATH INDICES { ASTNode::add_lookup_entry($1, $2, $3); } - ; - -//index: NUMBER comma index { ASTNode::extend_current_lookup_indices($1); } -// | NUMBER { ASTNode::extend_current_lookup_indices($1); } -// ; - -list: list COMMA exp { $$ = $1 +1; } - | exp { $$ = 1;} - ; - -exp: ALIAS { $$ = createExpr(expr_stack, "ALIAS", $1, 0, 0); } -| ALIAS INDICES { createExpr(expr_stack, "ALIAS", $1, 0, 0); $$ = createExpr(expr_stack, "INDEX", $2, 0, 1); } -| PATH { $$ = createExpr(expr_stack, "PATH", $1, 0, 0); } -| NUMBER { $$ = createExpr(expr_stack, "NUM", "", $1, 0); } -| L_PAREN exp R_PAREN { $$ = $2; } -| exp OPERATOR exp { $$ = createExpr(expr_stack, $2, "", 0, 2); } -| FUNCTION L_PAREN list R_PAREN { $$ = createExpr(expr_stack, $1, "", 0, $3); } - ; -%% +%define parse.trace +%define parse.error detailed +%define parse.lac full -void* createExpr(std::stack* expr_stack, std::string str_op, const char* name, double value, size_t numsubexprs) { - std::cout << "Creating ASTNode in function createExpr" << std::endl; - std::cout << "\tstack size: " << expr_stack->size() << "\n\top: " << str_op << "\n\tname: " << name << "\n\tvalue: " << value << "\n\tnumsubexprs: " << numsubexprs << std::endl; - - ExprHelper::expr_op op = ExprHelper::get_op(str_op); - - ASTNode *node = new ASTNode(op); - switch(op) { - case ExprHelper::OP_ALIAS: - node = new ASTNode(op, name); - break; - case ExprHelper::OP_PATH: - node = new ASTNode(op, name); - break; - case ExprHelper::OP_NUM: - node = new ASTNode(op, value); - break; - case ExprHelper::OP_INDEX: - // TODO: translate indices - node = new ASTNode(op, name); - break; - default: - node = new ASTNode(op); - }; - node->extend_subexprs(numsubexprs); - for (size_t i = 1; i <= numsubexprs; ++i) - { - ASTNode *subexpr = expr_stack->top(); - node->add_back_subexpr(subexpr,i); - expr_stack->pop(); - } - expr_stack->push(node); - - return &expr_stack->top(); +%code { +#include "ASTDriver.h" +#include "ASTNode.h" } -Expression* parse_expression(const char* input) { - yy_scan_string(input); - std::stack expr_stack; - yyparse(&expr_stack); +%define api.token.prefix {TOK_} +%token + ASSIGN ":=" + COMMA "," + COLON ":" + L_PAREN "(" + R_PAREN ")" + L_BRACE "[" + R_BRACE "]" + ENDL "\n" + VAR "var" +; + +/* +%token NUM +%token ALIAS +%token PATH +%token FUNCTION +*/ +%token OPERATOR +/* +%token > INDICES +*/ +%token IDENTIFIER "identifier" +%token VARNAME +%token INT "number" +%nterm exp +%nterm list +%nterm >> indices_list +%nterm > index - // DEBUGGING - std::cout << "yyparse complete. Stack size: " << expr_stack.size() << std::endl; - std::cout << "parser prettyprint:" << std::endl; - expr_stack.top()->printpretty(""); +%% +%start unit; +unit: assignments exp { /*drv.root = $2;*//*drv.result = $2;*/ }; + +assignments: + %empty {} +| VAR assignment ENDL assignments {} + +assignment: + IDENTIFIER ASSIGN VARNAME { drv.add_lookup_entry($1, $3); } +| IDENTIFIER ASSIGN IDENTIFIER { drv.add_lookup_entry($1, $3); } +| IDENTIFIER ASSIGN VARNAME L_BRACE indices_list R_BRACE { drv.add_lookup_entry($1, $3, $5); } +| IDENTIFIER ASSIGN IDENTIFIER L_BRACE indices_list R_BRACE { drv.add_lookup_entry($1, $3, $5); }; + +indices_list: +indices_list COMMA index { $1.push_back($3); $$ = $1; } +| index { $$ = {$1}; } +| %empty { $$ = {}; }; + +index: +INT COLON INT COLON INT { $$ = {$1, $3, $5}; } +| COLON INT COLON INT { $$ = {-1, $2, $4}; } +| INT COLON COLON INT { $$ = {$1, -1, $4}; } +| INT COLON INT COLON { $$ = {$1, $3, 1}; } +| INT COLON INT { $$ = {$1, $3, 1}; } +| COLON COLON INT { $$ = {-1, -1, $3}; } +| COLON INT COLON { $$ = {-1, $2, 1}; } +| COLON INT { $$ = {-1, $2, 1}; } +| INT COLON COLON { $$ = {$1, -1, 1}; } +| INT COLON { $$ = {$1, -1, 1}; } +| INT { $$ = {$1, $1, 1}; } +| %empty { $$ = {-1, -1, 1}; } +; + +exp: + "number" +| exp OPERATOR exp { drv.createNode($2, 2); } +| IDENTIFIER "(" list ")" { drv.createNode($1, $3); } +| IDENTIFIER "[" indices_list "]" { drv.createNode($1, $3); } +| IDENTIFIER { drv.createNode($1); } +| "(" exp ")" { } +; + +list: +exp COMMA list { $$ = $3 + 1; } +| exp { $$ = 1; } +| %empty { $$ = 0; } +%% - Expression *dummy_root = new Expression(); - expr_stack.top()->to_expr(dummy_root); - return std::get<0>(dummy_root->sub_exprs[0]); +void +adios2::detail::parser::error (const location_type& l, const std::string& m) +{ + std::cerr << l << ": " << m << '\n'; } - -void yyerror(std::stack* expr_stack, const char *msg) { - printf("** Line %d: %s\n", yylloc.first_line, msg); -} \ No newline at end of file diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Makefile b/source/adios2/toolkit/derived/parser/pregen-source/Makefile new file mode 100644 index 0000000000..3b1342ce16 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/Makefile @@ -0,0 +1,27 @@ +USE_BISON_3.8 = true +CC = g++ +PARSER_SOURCE = ../ +OPT = -std=c++11 -I$(PARSER_SOURCE) -I./ +ifdef USE_BISON_3.8 +BISON = /usr/local/Cellar/bison/3.8.2/bin/bison +PARSER = parser.y +else +BISON = /usr/bin/bison +PARSER = parser.y +endif + +simple-c: $(PARSER_SOURCE)/driver.cpp $(PARSER_SOURCE)/ASTDriver.cpp $(PARSER_SOURCE)/ASTNode.cpp lexer.cpp parser.cpp + $(CC) $(OPT) $^ -o $@ + +lexer.h lexer.cpp: $(PARSER_SOURCE)/lexer.l + flex --header-file=lexer.h -o lexer.cpp $(PARSER_SOURCE)/lexer.l + +parser.h parser.cpp: $(PARSER_SOURCE)/$(PARSER) + $(BISON) --version + $(BISON) -d -v --defines=parser.h -o parser.cpp $(PARSER_SOURCE)/$(PARSER) +ifndef USE_BISON_3.8 + echo "\n#include \"ASTNode.h\"\n\nASTNode* parse_expression(const char* input);" >> parser.h +endif + +clean: + rm *.o *~ lexer.cpp lexer.h parser.cpp parser.h parser.hpp parser.output location.hh simple-c diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp new file mode 100644 index 0000000000..6e6f5b3021 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -0,0 +1,2233 @@ +#line 1 "lexer.cpp" + +#line 3 "lexer.cpp" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +/* %not-for-header */ +/* %if-c-only */ +/* %if-not-reentrant */ + +/* %endif */ +/* %endif */ +/* %ok-for-header */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* %if-c++-only */ +/* %endif */ + +/* %if-c-only */ + +/* %endif */ + +/* %if-c-only */ + +/* %endif */ + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +/* %if-c-only */ +#include +#include +#include +#include +/* %endif */ + +/* %if-tables-serialization */ +/* %endif */ +/* end standard C headers. */ + +/* %if-c-or-c++ */ +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +typedef uint64_t flex_uint64_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* %endif */ + +/* begin standard C++ headers. */ +/* %if-c++-only */ +/* %endif */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* %not-for-header */ +/* Returned upon end-of-file. */ +#define YY_NULL 0 +/* %ok-for-header */ + +/* %not-for-header */ +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) +/* %ok-for-header */ + +/* %if-reentrant */ +/* %endif */ + +/* %if-not-reentrant */ + +/* %endif */ + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +/* %if-not-reentrant */ +extern yy_size_t yyleng; +/* %endif */ + +/* %if-c-only */ +/* %if-not-reentrant */ +extern FILE *yyin, *yyout; +/* %endif */ +/* %endif */ + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { +/* %if-c-only */ + FILE *yy_input_file; +/* %endif */ + +/* %if-c++-only */ +/* %endif */ + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + yy_size_t yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* %if-c-only Standard (non-C++) definition */ +/* %not-for-header */ +/* %if-not-reentrant */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ +/* %endif */ +/* %ok-for-header */ + +/* %endif */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* %if-c-only Standard (non-C++) definition */ + +/* %if-not-reentrant */ +/* %not-for-header */ +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ +yy_size_t yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; +/* %ok-for-header */ + +/* %endif */ + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); + +/* %endif */ + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP + +#define FLEX_DEBUG +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +/* %% [1.5] DFA */ + +/* %if-c-only Standard (non-C++) definition */ + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* %endif */ + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ +/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ + yyleng = (yy_size_t) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ +/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ + (yy_c_buf_p) = yy_cp; +/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ +#define YY_NUM_RULES 16 +#define YY_END_OF_BUFFER 17 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[26] = + { 0, + 0, 0, 17, 15, 1, 2, 6, 7, 12, 4, + 10, 5, 13, 8, 9, 13, 1, 2, 10, 3, + 14, 13, 13, 11, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, + 5, 6, 6, 7, 8, 9, 8, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 11, 1, 1, + 12, 1, 1, 1, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 14, 9, 15, 6, 16, 1, 17, 13, 13, 13, + + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 18, 13, 13, 13, 19, 13, 13, + 13, 13, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[20] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, + 1, 1, 2, 1, 1, 2, 2, 2, 2 + } ; + +static const flex_int16_t yy_base[28] = + { 0, + 0, 0, 38, 39, 35, 33, 39, 39, 39, 39, + 25, 22, 12, 39, 39, 14, 31, 29, 20, 39, + 0, 12, 7, 11, 39, 25, 24 + } ; + +static const flex_int16_t yy_def[28] = + { 0, + 25, 1, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 26, 25, 25, 26, 25, 25, 25, 25, + 27, 16, 16, 16, 0, 25, 25 + } ; + +static const flex_int16_t yy_nxt[59] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 9, 4, 11, + 12, 4, 13, 14, 15, 4, 13, 13, 16, 21, + 21, 21, 21, 22, 24, 21, 22, 22, 22, 19, + 23, 18, 17, 20, 19, 18, 17, 25, 3, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25 + } ; + +static const flex_int16_t yy_chk[59] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 13, + 13, 16, 16, 23, 23, 27, 26, 24, 22, 19, + 16, 18, 17, 12, 11, 6, 5, 3, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, + 25, 25, 25, 25, 25, 25, 25, 25 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 1; + +static const flex_int16_t yy_rule_linenum[16] = + { 0, + 128, 129, 131, 132, 133, 134, 135, 136, 137, 139, + 140, 141, 142, 143, 144 + } ; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "..//lexer.l" +/* Scanner for calc++. -*- C++ -*- + + Copyright (C) 2005-2015, 2018-2021 Free Software Foundation, Inc. + + This file is part of Bison, the GNU Compiler Compiler. + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . */ +#line 21 "..//lexer.l" +# include +# include +# include +# include // strerror +# include +#include "ASTDriver.h" +# include "parser.h" +#line 573 "lexer.cpp" +#line 31 "..//lexer.l" +#if defined __clang__ +# define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#endif + +// Clang and ICC like to pretend they are GCC. +#if defined __GNUC__ && !defined __clang__ && !defined __ICC +# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#endif + +// Pacify warnings in yy_init_buffer (observed with Flex 2.6.4) +// and GCC 6.4.0, 7.3.0 with -O3. +#if defined GCC_VERSION && 600 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wnull-dereference" +#endif + +// This example uses Flex's C back end, yet compiles it as C++. +// So expect warnings about C style casts and NULL. +#if defined CLANG_VERSION && 500 <= CLANG_VERSION +# pragma clang diagnostic ignored "-Wold-style-cast" +# pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#elif defined GCC_VERSION && 407 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wold-style-cast" +# pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif + +#define FLEX_VERSION (YY_FLEX_MAJOR_VERSION * 100 + YY_FLEX_MINOR_VERSION) + +// Old versions of Flex (2.5.35) generate an incomplete documentation comment. +// +// In file included from src/scan-code-c.c:3: +// src/scan-code.c:2198:21: error: empty paragraph passed to '@param' command +// [-Werror,-Wdocumentation] +// * @param line_number +// ~~~~~~~~~~~~~~~~~^ +// 1 error generated. +#if FLEX_VERSION < 206 && defined CLANG_VERSION +# pragma clang diagnostic ignored "-Wdocumentation" +#endif + +// Old versions of Flex (2.5.35) use 'register'. Warnings introduced in +// GCC 7 and Clang 6. +#if FLEX_VERSION < 206 +# if defined CLANG_VERSION && 600 <= CLANG_VERSION +# pragma clang diagnostic ignored "-Wdeprecated-register" +# elif defined GCC_VERSION && 700 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wregister" +# endif +#endif + +#if FLEX_VERSION < 206 +# if defined CLANG_VERSION +# pragma clang diagnostic ignored "-Wconversion" +# pragma clang diagnostic ignored "-Wdocumentation" +# pragma clang diagnostic ignored "-Wshorten-64-to-32" +# pragma clang diagnostic ignored "-Wsign-conversion" +# elif defined GCC_VERSION +# pragma GCC diagnostic ignored "-Wconversion" +# pragma GCC diagnostic ignored "-Wsign-conversion" +# endif +#endif + +// Flex 2.6.4, GCC 9 +// warning: useless cast to type 'int' [-Wuseless-cast] +// 1361 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); +// | ^ +#if defined GCC_VERSION && 900 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wuseless-cast" +#endif +#line 643 "lexer.cpp" +#define YY_NO_INPUT 1 +#line 104 "..//lexer.l" + // A number symbol corresponding to the value in S. + adios2::detail::parser::symbol_type + make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); +#line 649 "lexer.cpp" +#line 117 "..//lexer.l" + // Code run each time a pattern is matched. + # define YY_USER_ACTION loc.columns (yyleng); +#line 653 "lexer.cpp" +#line 654 "lexer.cpp" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +/* %if-c-only */ +#include +/* %endif */ +/* %if-c++-only */ +/* %endif */ +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +/* %if-c-only Reentrant structure and macros (non-C++). */ +/* %if-reentrant */ +/* %if-c-only */ + +static int yy_init_globals ( void ); + +/* %endif */ +/* %if-reentrant */ +/* %endif */ +/* %endif End reentrant structures and macros. */ + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + yy_size_t yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* %if-bison-bridge */ +/* %endif */ + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +/* %not-for-header */ +#ifndef YY_NO_UNPUT + +#endif +/* %ok-for-header */ + +/* %endif */ + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +/* %if-c-only Standard (non-C++) definition */ +/* %not-for-header */ +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif +/* %ok-for-header */ + +/* %endif */ +#endif + +/* %if-c-only */ + +/* %endif */ + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* %if-c-only Standard (non-C++) definition */ +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +/* %endif */ +/* %if-c++-only C++ definition */ +/* %endif */ +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ +/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + yy_size_t n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ +/* %if-c++-only C++ definition \ */\ +/* %endif */ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +/* %if-c-only */ +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +#endif + +/* %if-tables-serialization structures and prototypes */ +/* %not-for-header */ +/* %ok-for-header */ + +/* %not-for-header */ +/* %tables-yydmap generated elements */ +/* %endif */ +/* end tables serialization structures and prototypes */ + +/* %ok-for-header */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 +/* %if-c-only Standard (non-C++) definition */ + +extern int yylex (void); + +#define YY_DECL int yylex (void) +/* %endif */ +/* %if-c++-only C++ definition */ +/* %endif */ +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +/* %% [6.0] YY_RULE_SETUP definition goes here */ +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/* %not-for-header */ +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) +/* %if-c-only */ + yyin = stdin; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + + if ( ! yyout ) +/* %if-c-only */ + yyout = stdout; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +/* %% [7.0] user's declarations go here */ +#line 120 "..//lexer.l" + + +#line 123 "..//lexer.l" + // A handy shortcut to the location held by the ASTDriver. + adios2::detail::location& loc = drv.location; + // Code run each time yylex is called. + loc.step (); + +#line 941 "lexer.cpp" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { +/* %% [8.0] yymore()-related code goes here */ + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + +/* %% [9.0] code to set up and find next match goes here */ + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 26 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_current_state != 25 ); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + +yy_find_action: +/* %% [10.0] code to find the action number goes here */ + yy_act = yy_accept[yy_current_state]; + + YY_DO_BEFORE_ACTION; + +/* %% [11.0] code for yylineno update goes here */ + +do_action: /* This label is used only to access EOF actions. */ + +/* %% [12.0] debug code goes here */ + if ( yy_flex_debug ) + { + if ( yy_act == 0 ) + fprintf( stderr, "--scanner backing up\n" ); + else if ( yy_act < 16 ) + fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", + (long)yy_rule_linenum[yy_act], yytext ); + else if ( yy_act == 16 ) + fprintf( stderr, "--accepting default rule (\"%s\")\n", + yytext ); + else if ( yy_act == 17 ) + fprintf( stderr, "--(end of buffer or a NUL)\n" ); + else + fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); + } + + switch ( yy_act ) + { /* beginning of action switch */ +/* %% [13.0] actions go here */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 128 "..//lexer.l" +loc.step (); + YY_BREAK +case 2: +/* rule 2 can match eol */ +YY_RULE_SETUP +#line 129 "..//lexer.l" +loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); + YY_BREAK +case 3: +YY_RULE_SETUP +#line 131 "..//lexer.l" +return adios2::detail::parser::make_ASSIGN (loc); + YY_BREAK +case 4: +YY_RULE_SETUP +#line 132 "..//lexer.l" +return adios2::detail::parser::make_COMMA (loc); + YY_BREAK +case 5: +YY_RULE_SETUP +#line 133 "..//lexer.l" +return adios2::detail::parser::make_COLON (loc); + YY_BREAK +case 6: +YY_RULE_SETUP +#line 134 "..//lexer.l" +return adios2::detail::parser::make_L_PAREN (loc); + YY_BREAK +case 7: +YY_RULE_SETUP +#line 135 "..//lexer.l" +return adios2::detail::parser::make_R_PAREN (loc); + YY_BREAK +case 8: +YY_RULE_SETUP +#line 136 "..//lexer.l" +return adios2::detail::parser::make_L_BRACE (loc); + YY_BREAK +case 9: +YY_RULE_SETUP +#line 137 "..//lexer.l" +return adios2::detail::parser::make_R_BRACE (loc); + YY_BREAK +case 10: +YY_RULE_SETUP +#line 139 "..//lexer.l" +return make_INT (yytext, loc); + YY_BREAK +case 11: +YY_RULE_SETUP +#line 140 "..//lexer.l" +return adios2::detail::parser::make_VAR (loc); + YY_BREAK +case 12: +YY_RULE_SETUP +#line 141 "..//lexer.l" +return adios2::detail::parser::make_OPERATOR (yytext, loc); + YY_BREAK +case 13: +YY_RULE_SETUP +#line 142 "..//lexer.l" +return adios2::detail::parser::make_IDENTIFIER (yytext, loc); + YY_BREAK +case 14: +YY_RULE_SETUP +#line 143 "..//lexer.l" +return adios2::detail::parser::make_VARNAME (yytext, loc); + YY_BREAK +case 15: +YY_RULE_SETUP +#line 144 "..//lexer.l" +{ + throw adios2::detail::parser::syntax_error + (loc, "invalid character: " + std::string(yytext)); +} + YY_BREAK +case YY_STATE_EOF(INITIAL): +#line 148 "..//lexer.l" +return adios2::detail::parser::make_YYEOF (loc); + YY_BREAK +case 16: +YY_RULE_SETUP +#line 149 "..//lexer.l" +ECHO; + YY_BREAK +#line 1105 "lexer.cpp" + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; +/* %if-c-only */ + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { +/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ +/* %ok-for-header */ + +/* %if-c++-only */ +/* %not-for-header */ +/* %ok-for-header */ + +/* %endif */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +/* %if-c-only */ +static int yy_get_next_buffer (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + yy_size_t num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + yy_size_t new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +/* %if-c-only */ +/* %not-for-header */ + static yy_state_type yy_get_previous_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + yy_state_type yy_current_state; + char *yy_cp; + +/* %% [15.0] code to get the start state into yy_current_state goes here */ + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { +/* %% [16.0] code to find the next state goes here */ + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 26 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ +/* %if-c-only */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + int yy_is_jam; + /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */ + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 26 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 25); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT +/* %if-c-only */ + +/* %endif */ +#endif + +/* %if-c-only */ +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + +/* %% [19.0] update BOL and yylineno */ + + return c; +} +/* %if-c-only */ +#endif /* ifndef YY_NO_INPUT */ +/* %endif */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ +/* %if-c-only */ + void yyrestart (FILE * input_file ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/* %if-c++-only */ +/* %endif */ + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ +/* %if-c-only */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +/* %if-c-only */ +static void yy_load_buffer_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; +/* %if-c-only */ + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ +/* %if-c-only */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/* %if-c++-only */ +/* %endif */ + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ +/* %if-c-only */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ +/* %if-c-only */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + +/* %if-c-only */ + b->yy_input_file = file; +/* %endif */ +/* %if-c++-only */ +/* %endif */ + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + +/* %if-c-only */ + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + +/* %endif */ +/* %if-c++-only */ +/* %endif */ + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ +/* %if-c-only */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/* %if-c-or-c++ */ +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +/* %if-c-only */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} +/* %endif */ + +/* %if-c-or-c++ */ +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +/* %if-c-only */ +void yypop_buffer_state (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} +/* %endif */ + +/* %if-c-or-c++ */ +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +/* %if-c-only */ +static void yyensure_buffer_stack (void) +/* %endif */ +/* %if-c++-only */ +/* %endif */ +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} +/* %endif */ + +/* %if-c-only */ +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} +/* %endif */ + +/* %if-c-only */ +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} +/* %endif */ + +/* %if-c-only */ +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, yy_size_t _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + yy_size_t i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} +/* %endif */ + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +/* %if-c-only */ +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} +/* %endif */ +/* %if-c++-only */ +/* %endif */ + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + yy_size_t yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/* %if-c-only */ +/* %if-reentrant */ +/* %endif */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +yy_size_t yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/* %if-reentrant */ +/* %endif */ + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +/* %endif */ + +/* %if-reentrant */ +/* %if-bison-bridge */ +/* %endif */ +/* %endif if-c-only */ + +/* %if-c-only */ +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} +/* %endif */ + +/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + +/* %if-reentrant */ +/* %endif */ + return 0; +} +/* %endif */ + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +/* %if-tables-serialization definitions */ +/* %define-yytables The name for this specific scanner's tables. */ +#define YYTABLES_NAME "yytables" +/* %endif */ + +/* %ok-for-header */ + +#line 149 "..//lexer.l" + + +adios2::detail::parser::symbol_type +make_INT (const std::string &s, const adios2::detail::parser::location_type& loc) +{ + errno = 0; + long n = strtol (s.c_str(), NULL, 10); + if (! (INT_MIN <= n && n <= INT_MAX && errno != ERANGE)) + throw adios2::detail::parser::syntax_error (loc, "integer is out of range: " + s); + return adios2::detail::parser::make_INT ((int) n, loc); +} + +ASTNode* +ASTDriver::parse (const char* input) +{ + adios2::detail::parser parse (*this); + yy_scan_string(input); + parse.set_debug_level (trace_parsing); + parse (); + std::cout << "Parsed input: " << input << std::endl; + return getAST(); +} + diff --git a/source/adios2/toolkit/derived/parser/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h similarity index 61% rename from source/adios2/toolkit/derived/parser/lexer.h rename to source/adios2/toolkit/derived/parser/pregen-source/lexer.h index 75c3a14657..23fe8df056 100644 --- a/source/adios2/toolkit/derived/parser/lexer.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h @@ -6,10 +6,12 @@ #line 7 "lexer.h" -#define YY_INT_ALIGNED short int +#define YY_INT_ALIGNED short int /* A lexical scanner generated by flex */ +/* %not-for-header */ + #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 @@ -18,16 +20,32 @@ #define FLEX_BETA #endif +/* %if-c++-only */ +/* %endif */ + +/* %if-c-only */ + +/* %endif */ + +/* %if-c-only */ + +/* %endif */ + /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ -#include +/* %if-c-only */ #include -#include #include +#include +#include +/* %endif */ +/* %if-tables-serialization */ +/* %endif */ /* end standard C headers. */ +/* %if-c-or-c++ */ /* flex integer type definitions */ #ifndef FLEXINT_H @@ -35,10 +53,10 @@ /* C99 systems have . Non-C99 systems may or may not. */ -#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. + * if you want the limit (max/min) macros for int types. */ #ifndef __STDC_LIMIT_MACROS #define __STDC_LIMIT_MACROS 1 @@ -56,48 +74,52 @@ typedef uint64_t flex_uint64_t; typedef signed char flex_int8_t; typedef short int flex_int16_t; typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; +typedef unsigned char flex_uint8_t; typedef unsigned short int flex_uint16_t; typedef unsigned int flex_uint32_t; /* Limits of integral types. */ #ifndef INT8_MIN -#define INT8_MIN (-128) +#define INT8_MIN (-128) #endif #ifndef INT16_MIN -#define INT16_MIN (-32767 - 1) +#define INT16_MIN (-32767-1) #endif #ifndef INT32_MIN -#define INT32_MIN (-2147483647 - 1) +#define INT32_MIN (-2147483647-1) #endif #ifndef INT8_MAX -#define INT8_MAX (127) +#define INT8_MAX (127) #endif #ifndef INT16_MAX -#define INT16_MAX (32767) +#define INT16_MAX (32767) #endif #ifndef INT32_MAX -#define INT32_MAX (2147483647) +#define INT32_MAX (2147483647) #endif #ifndef UINT8_MAX -#define UINT8_MAX (255U) +#define UINT8_MAX (255U) #endif #ifndef UINT16_MAX -#define UINT16_MAX (65535U) +#define UINT16_MAX (65535U) #endif #ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) +#define UINT32_MAX (4294967295U) #endif #ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) +#define SIZE_MAX (~(size_t)0) #endif #endif /* ! C99 */ #endif /* ! FLEXINT_H */ +/* %endif */ + /* begin standard C++ headers. */ +/* %if-c++-only */ +/* %endif */ /* TODO: this is always defined, so inline it */ #define yyconst const @@ -108,6 +130,17 @@ typedef unsigned int flex_uint32_t; #define yynoreturn #endif +/* %not-for-header */ + +/* %not-for-header */ + +/* %if-reentrant */ +/* %endif */ + +/* %if-not-reentrant */ + +/* %endif */ + /* Size of default input buffer. */ #ifndef YY_BUF_SIZE #ifdef __ia64__ @@ -131,81 +164,110 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif +/* %if-not-reentrant */ extern yy_size_t yyleng; +/* %endif */ +/* %if-c-only */ +/* %if-not-reentrant */ extern FILE *yyin, *yyout; +/* %endif */ +/* %endif */ #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state -{ - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - yy_size_t yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; + { +/* %if-c-only */ + FILE *yy_input_file; +/* %endif */ + +/* %if-c++-only */ +/* %endif */ + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + yy_size_t yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; int yy_bs_lineno; /**< The line count. */ int yy_bs_column; /**< The column count. */ - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; - int yy_buffer_status; -}; + }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ -void yyrestart(FILE *input_file); -void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer); -YY_BUFFER_STATE yy_create_buffer(FILE *file, int size); -void yy_delete_buffer(YY_BUFFER_STATE b); -void yy_flush_buffer(YY_BUFFER_STATE b); -void yypush_buffer_state(YY_BUFFER_STATE new_buffer); -void yypop_buffer_state(void); +/* %if-c-only Standard (non-C++) definition */ +/* %not-for-header */ + +/* %endif */ + +/* %if-c-only Standard (non-C++) definition */ + +/* %if-not-reentrant */ +/* %not-for-header */ -YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size); -YY_BUFFER_STATE yy_scan_string(const char *yy_str); -YY_BUFFER_STATE yy_scan_bytes(const char *bytes, yy_size_t len); +/* %endif */ -void *yyalloc(yy_size_t); -void *yyrealloc(void *, yy_size_t); -void yyfree(void *); +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); + +/* %endif */ + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ -#define yywrap() (/*CONSTCOND*/ 1) +#define yywrap() (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP +#define FLEX_DEBUG + extern int yylineno; extern char *yytext; @@ -214,6 +276,10 @@ extern char *yytext; #endif #define yytext_ptr yytext +/* %if-c-only Standard (non-C++) definition */ + +/* %endif */ + #ifdef YY_HEADER_EXPORT_START_CONDITIONS #define INITIAL 0 @@ -224,41 +290,57 @@ extern char *yytext; * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ +/* %if-c-only */ #include +/* %endif */ +/* %if-c++-only */ +/* %endif */ #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif +/* %if-c-only Reentrant structure and macros (non-C++). */ +/* %if-reentrant */ +/* %if-c-only */ + +/* %endif */ +/* %if-reentrant */ +/* %endif */ +/* %endif End reentrant structures and macros. */ + /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ -int yylex_destroy(void); +int yylex_destroy ( void ); -int yyget_debug(void); +int yyget_debug ( void ); -void yyset_debug(int debug_flag); +void yyset_debug ( int debug_flag ); -YY_EXTRA_TYPE yyget_extra(void); +YY_EXTRA_TYPE yyget_extra ( void ); -void yyset_extra(YY_EXTRA_TYPE user_defined); +void yyset_extra ( YY_EXTRA_TYPE user_defined ); -FILE *yyget_in(void); +FILE *yyget_in ( void ); -void yyset_in(FILE *_in_str); +void yyset_in ( FILE * _in_str ); -FILE *yyget_out(void); +FILE *yyget_out ( void ); -void yyset_out(FILE *_out_str); +void yyset_out ( FILE * _out_str ); -yy_size_t yyget_leng(void); + yy_size_t yyget_leng ( void ); -char *yyget_text(void); +char *yyget_text ( void ); -int yyget_lineno(void); +int yyget_lineno ( void ); -void yyset_lineno(int _line_number); +void yyset_lineno ( int _line_number ); + +/* %if-bison-bridge */ +/* %endif */ /* Macros after this point can all be overridden by user definitions in * section 1. @@ -266,24 +348,35 @@ void yyset_lineno(int _line_number); #ifndef YY_SKIP_YYWRAP #ifdef __cplusplus -extern "C" int yywrap(void); +extern "C" int yywrap ( void ); #else -extern int yywrap(void); +extern int yywrap ( void ); #endif #endif +/* %not-for-header */ + +/* %endif */ + #ifndef yytext_ptr -static void yy_flex_strncpy(char *, const char *, int); +static void yy_flex_strncpy ( char *, const char *, int ); #endif #ifdef YY_NEED_STRLEN -static int yy_flex_strlen(const char *); +static int yy_flex_strlen ( const char * ); #endif #ifndef YY_NO_INPUT +/* %if-c-only Standard (non-C++) definition */ +/* %not-for-header */ +/* %endif */ #endif +/* %if-c-only */ + +/* %endif */ + /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #ifdef __ia64__ @@ -299,19 +392,38 @@ static int yy_flex_strlen(const char *); #define YY_START_STACK_INCR 25 #endif +/* %if-tables-serialization structures and prototypes */ +/* %not-for-header */ + +/* %not-for-header */ + /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 +/* %if-c-only Standard (non-C++) definition */ -extern int yylex(void); +extern int yylex (void); -#define YY_DECL int yylex(void) +#define YY_DECL int yylex (void) +/* %endif */ +/* %if-c++-only C++ definition */ +/* %endif */ #endif /* !YY_DECL */ +/* %not-for-header */ + +/* %if-c++-only */ +/* %not-for-header */ + +/* %endif */ + /* yy_get_previous_state - get the state just before the EOB char was reached */ +/* %if-c-only */ +/* %not-for-header */ + #undef YY_NEW_FILE #undef YY_FLUSH_BUFFER #undef yy_set_bol @@ -469,8 +581,9 @@ extern int yylex(void); #undef yyTABLES_NAME #endif -#line 47 "lexer.l" +#line 149 "..//lexer.l" + -#line 476 "lexer.h" +#line 587 "lexer.h" #undef yyIN_HEADER #endif /* yyHEADER_H */ diff --git a/source/adios2/toolkit/derived/parser/pregen-source/location.hh b/source/adios2/toolkit/derived/parser/pregen-source/location.hh new file mode 100644 index 0000000000..3669262d92 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/location.hh @@ -0,0 +1,306 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Locations for Bison parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + +/** + ** \file location.hh + ** Define the adios2::detail::location class. + */ + +#ifndef YY_YY_LOCATION_HH_INCLUDED +# define YY_YY_LOCATION_HH_INCLUDED + +# include +# include + +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +#line 6 "..//parser.y" +namespace adios2 { namespace detail { +#line 59 "location.hh" + + /// A point in a source file. + class position + { + public: + /// Type for file name. + typedef const std::string filename_type; + /// Type for line and column numbers. + typedef int counter_type; + + /// Construct a position. + explicit position (filename_type* f = YY_NULLPTR, + counter_type l = 1, + counter_type c = 1) + : filename (f) + , line (l) + , column (c) + {} + + + /// Initialization. + void initialize (filename_type* fn = YY_NULLPTR, + counter_type l = 1, + counter_type c = 1) + { + filename = fn; + line = l; + column = c; + } + + /** \name Line and Column related manipulators + ** \{ */ + /// (line related) Advance to the COUNT next lines. + void lines (counter_type count = 1) + { + if (count) + { + column = 1; + line = add_ (line, count, 1); + } + } + + /// (column related) Advance to the COUNT next columns. + void columns (counter_type count = 1) + { + column = add_ (column, count, 1); + } + /** \} */ + + /// File name to which this position refers. + filename_type* filename; + /// Current line number. + counter_type line; + /// Current column number. + counter_type column; + + private: + /// Compute max (min, lhs+rhs). + static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min) + { + return lhs + rhs < min ? min : lhs + rhs; + } + }; + + /// Add \a width columns, in place. + inline position& + operator+= (position& res, position::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns. + inline position + operator+ (position res, position::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns, in place. + inline position& + operator-= (position& res, position::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns. + inline position + operator- (position res, position::counter_type width) + { + return res -= width; + } + + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param pos a reference to the position to redirect + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const position& pos) + { + if (pos.filename) + ostr << *pos.filename << ':'; + return ostr << pos.line << '.' << pos.column; + } + + /// Two points in a source file. + class location + { + public: + /// Type for file name. + typedef position::filename_type filename_type; + /// Type for line and column numbers. + typedef position::counter_type counter_type; + + /// Construct a location from \a b to \a e. + location (const position& b, const position& e) + : begin (b) + , end (e) + {} + + /// Construct a 0-width location in \a p. + explicit location (const position& p = position ()) + : begin (p) + , end (p) + {} + + /// Construct a 0-width location in \a f, \a l, \a c. + explicit location (filename_type* f, + counter_type l = 1, + counter_type c = 1) + : begin (f, l, c) + , end (f, l, c) + {} + + + /// Initialization. + void initialize (filename_type* f = YY_NULLPTR, + counter_type l = 1, + counter_type c = 1) + { + begin.initialize (f, l, c); + end = begin; + } + + /** \name Line and Column related manipulators + ** \{ */ + public: + /// Reset initial location to final location. + void step () + { + begin = end; + } + + /// Extend the current location to the COUNT next columns. + void columns (counter_type count = 1) + { + end += count; + } + + /// Extend the current location to the COUNT next lines. + void lines (counter_type count = 1) + { + end.lines (count); + } + /** \} */ + + + public: + /// Beginning of the located region. + position begin; + /// End of the located region. + position end; + }; + + /// Join two locations, in place. + inline location& + operator+= (location& res, const location& end) + { + res.end = end.end; + return res; + } + + /// Join two locations. + inline location + operator+ (location res, const location& end) + { + return res += end; + } + + /// Add \a width columns to the end position, in place. + inline location& + operator+= (location& res, location::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns to the end position. + inline location + operator+ (location res, location::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns to the end position, in place. + inline location& + operator-= (location& res, location::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns to the end position. + inline location + operator- (location res, location::counter_type width) + { + return res -= width; + } + + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param loc a reference to the location to redirect + ** + ** Avoid duplicate information. + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const location& loc) + { + location::counter_type end_col + = 0 < loc.end.column ? loc.end.column - 1 : 0; + ostr << loc.begin; + if (loc.end.filename + && (!loc.begin.filename + || *loc.begin.filename != *loc.end.filename)) + ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; + else if (loc.begin.line < loc.end.line) + ostr << '-' << loc.end.line << '.' << end_col; + else if (loc.begin.column < end_col) + ostr << '-' << end_col; + return ostr; + } + +#line 6 "..//parser.y" +} } // adios2::detail +#line 305 "location.hh" + +#endif // !YY_YY_LOCATION_HH_INCLUDED diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp new file mode 100644 index 0000000000..1ea0a8687a --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp @@ -0,0 +1,1427 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Skeleton implementation for Bison LALR(1) parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. + + + + + +#include "parser.h" + + +// Unqualified %code blocks. +#line 27 "..//parser.y" + +#include "ASTDriver.h" +#include "ASTNode.h" + +#line 51 "parser.cpp" + + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include // FIXME: INFRINGES ON USER NAME SPACE. +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (false) +# endif + + +// Enable debugging if requested. +#if YYDEBUG + +// A pseudo ostream that takes yydebug_ into account. +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ + } while (false) + +# define YY_STACK_PRINT() \ + do { \ + if (yydebug_) \ + yy_stack_print_ (); \ + } while (false) + +#else // !YYDEBUG + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) +# define YY_REDUCE_PRINT(Rule) static_cast (0) +# define YY_STACK_PRINT() static_cast (0) + +#endif // !YYDEBUG + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yyla.clear ()) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +#line 6 "..//parser.y" +namespace adios2 { namespace detail { +#line 144 "parser.cpp" + + /// Build a parser object. + parser::parser (ASTDriver& drv_yyarg) +#if YYDEBUG + : yydebug_ (false), + yycdebug_ (&std::cerr), +#else + : +#endif + yy_lac_established_ (false), + drv (drv_yyarg) + {} + + parser::~parser () + {} + + parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + /*---------. + | symbol. | + `---------*/ + + + + // by_state. + parser::by_state::by_state () YY_NOEXCEPT + : state (empty_state) + {} + + parser::by_state::by_state (const by_state& that) YY_NOEXCEPT + : state (that.state) + {} + + void + parser::by_state::clear () YY_NOEXCEPT + { + state = empty_state; + } + + void + parser::by_state::move (by_state& that) + { + state = that.state; + that.clear (); + } + + parser::by_state::by_state (state_type s) YY_NOEXCEPT + : state (s) + {} + + parser::symbol_kind_type + parser::by_state::kind () const YY_NOEXCEPT + { + if (state == empty_state) + return symbol_kind::S_YYEMPTY; + else + return YY_CAST (symbol_kind_type, yystos_[+state]); + } + + parser::stack_symbol_type::stack_symbol_type () + {} + + parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) + : super_type (YY_MOVE (that.state), YY_MOVE (that.location)) + { + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.YY_MOVE_OR_COPY< int > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_index: // index + value.YY_MOVE_OR_COPY< std::tuple > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.YY_MOVE_OR_COPY< std::vector> > (YY_MOVE (that.value)); + break; + + default: + break; + } + +#if 201103L <= YY_CPLUSPLUS + // that is emptied. + that.state = empty_state; +#endif + } + + parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) + : super_type (s, YY_MOVE (that.location)) + { + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.move< int > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (YY_MOVE (that.value)); + break; + + default: + break; + } + + // that is emptied. + that.kind_ = symbol_kind::S_YYEMPTY; + } + +#if YY_CPLUSPLUS < 201103L + parser::stack_symbol_type& + parser::stack_symbol_type::operator= (const stack_symbol_type& that) + { + state = that.state; + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.copy< int > (that.value); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.copy< std::string > (that.value); + break; + + case symbol_kind::S_index: // index + value.copy< std::tuple > (that.value); + break; + + case symbol_kind::S_indices_list: // indices_list + value.copy< std::vector> > (that.value); + break; + + default: + break; + } + + location = that.location; + return *this; + } + + parser::stack_symbol_type& + parser::stack_symbol_type::operator= (stack_symbol_type& that) + { + state = that.state; + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.move< int > (that.value); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (that.value); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (that.value); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (that.value); + break; + + default: + break; + } + + location = that.location; + // that is emptied. + that.state = empty_state; + return *this; + } +#endif + + template + void + parser::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const + { + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yysym); + } + +#if YYDEBUG + template + void + parser::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const + { + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + if (yysym.empty ()) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " (" + << yysym.location << ": "; + YY_USE (yykind); + yyo << ')'; + } + } +#endif + + void + parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) + { + if (m) + YY_SYMBOL_PRINT (m, sym); + yystack_.push (YY_MOVE (sym)); + } + + void + parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) + { +#if 201103L <= YY_CPLUSPLUS + yypush_ (m, stack_symbol_type (s, std::move (sym))); +#else + stack_symbol_type ss (s, sym); + yypush_ (m, ss); +#endif + } + + void + parser::yypop_ (int n) YY_NOEXCEPT + { + yystack_.pop (n); + } + +#if YYDEBUG + std::ostream& + parser::debug_stream () const + { + return *yycdebug_; + } + + void + parser::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + parser::debug_level_type + parser::debug_level () const + { + return yydebug_; + } + + void + parser::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif // YYDEBUG + + parser::state_type + parser::yy_lr_goto_state_ (state_type yystate, int yysym) + { + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS]; + } + + bool + parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yypact_ninf_; + } + + bool + parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yytable_ninf_; + } + + int + parser::operator() () + { + return parse (); + } + + int + parser::parse () + { + int yyn; + /// Length of the RHS of the rule being reduced. + int yylen = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// The lookahead symbol. + symbol_type yyla; + + /// The locations where the error started and ended. + stack_symbol_type yyerror_range[3]; + + /// The return value of parse (). + int yyresult; + + // Discard the LAC context in case there still is one left from a + // previous invocation. + yy_lac_discard_ ("init"); + +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + YYCDEBUG << "Starting parse\n"; + + + /* Initialize the stack. The initial state will be set in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystack_.clear (); + yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); + + /*-----------------------------------------------. + | yynewstate -- push a new symbol on the stack. | + `-----------------------------------------------*/ + yynewstate: + YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); + + // Accept? + if (yystack_[0].state == yyfinal_) + YYACCEPT; + + goto yybackup; + + + /*-----------. + | yybackup. | + `-----------*/ + yybackup: + // Try to take a decision without lookahead. + yyn = yypact_[+yystack_[0].state]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + // Read a lookahead token. + if (yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + symbol_type yylookahead (yylex (drv)); + yyla.move (yylookahead); + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + goto yyerrlab1; + } +#endif // YY_EXCEPTIONS + } + YY_SYMBOL_PRINT ("Next token is", yyla); + + if (yyla.kind () == symbol_kind::S_YYerror) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = symbol_kind::S_YYUNDEF; + goto yyerrlab1; + } + + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) + { + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab; + goto yydefault; + } + + // Reduce or error. + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab; + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab; + + yyn = -yyn; + goto yyreduce; + } + + // Count tokens shifted since error; after three, turn off error status. + if (yyerrstatus_) + --yyerrstatus_; + + // Shift the lookahead token. + yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla)); + yy_lac_discard_ ("shift"); + goto yynewstate; + + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[+yystack_[0].state]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + + /*-----------------------------. + | yyreduce -- do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + { + stack_symbol_type yylhs; + yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]); + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + switch (yyr1_[yyn]) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + yylhs.value.emplace< int > (); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + yylhs.value.emplace< std::string > (); + break; + + case symbol_kind::S_index: // index + yylhs.value.emplace< std::tuple > (); + break; + + case symbol_kind::S_indices_list: // indices_list + yylhs.value.emplace< std::vector> > (); + break; + + default: + break; + } + + + // Default location. + { + stack_type::slice range (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, range, yylen); + yyerror_range[1].location = yylhs.location; + } + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + switch (yyn) + { + case 2: // unit: assignments exp +#line 65 "..//parser.y" + { /*drv.root = $2;*//*drv.result = $2;*/ } +#line 649 "parser.cpp" + break; + + case 3: // assignments: %empty +#line 68 "..//parser.y" + {} +#line 655 "parser.cpp" + break; + + case 4: // assignments: "var" assignment "\n" assignments +#line 69 "..//parser.y" + {} +#line 661 "parser.cpp" + break; + + case 5: // assignment: "identifier" ":=" VARNAME +#line 72 "..//parser.y" + { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } +#line 667 "parser.cpp" + break; + + case 6: // assignment: "identifier" ":=" "identifier" +#line 73 "..//parser.y" + { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } +#line 673 "parser.cpp" + break; + + case 7: // assignment: "identifier" ":=" VARNAME "[" indices_list "]" +#line 74 "..//parser.y" + { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 679 "parser.cpp" + break; + + case 8: // assignment: "identifier" ":=" "identifier" "[" indices_list "]" +#line 75 "..//parser.y" + { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 685 "parser.cpp" + break; + + case 9: // indices_list: indices_list "," index +#line 78 "..//parser.y" + { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } +#line 691 "parser.cpp" + break; + + case 10: // indices_list: index +#line 79 "..//parser.y" + { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } +#line 697 "parser.cpp" + break; + + case 11: // indices_list: %empty +#line 80 "..//parser.y" + { yylhs.value.as < std::vector> > () = {}; } +#line 703 "parser.cpp" + break; + + case 12: // index: "number" ":" "number" ":" "number" +#line 83 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } +#line 709 "parser.cpp" + break; + + case 13: // index: ":" "number" ":" "number" +#line 84 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } +#line 715 "parser.cpp" + break; + + case 14: // index: "number" ":" ":" "number" +#line 85 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } +#line 721 "parser.cpp" + break; + + case 15: // index: "number" ":" "number" ":" +#line 86 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } +#line 727 "parser.cpp" + break; + + case 16: // index: "number" ":" "number" +#line 87 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } +#line 733 "parser.cpp" + break; + + case 17: // index: ":" ":" "number" +#line 88 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } +#line 739 "parser.cpp" + break; + + case 18: // index: ":" "number" ":" +#line 89 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } +#line 745 "parser.cpp" + break; + + case 19: // index: ":" "number" +#line 90 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } +#line 751 "parser.cpp" + break; + + case 20: // index: "number" ":" ":" +#line 91 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } +#line 757 "parser.cpp" + break; + + case 21: // index: "number" ":" +#line 92 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } +#line 763 "parser.cpp" + break; + + case 22: // index: "number" +#line 93 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } +#line 769 "parser.cpp" + break; + + case 23: // index: %empty +#line 94 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } +#line 775 "parser.cpp" + break; + + case 24: // exp: "number" +#line 98 "..//parser.y" + { yylhs.value.as < int > () = yystack_[0].value.as < int > (); } +#line 781 "parser.cpp" + break; + + case 25: // exp: exp OPERATOR exp +#line 99 "..//parser.y" + { drv.createNode(yystack_[1].value.as < std::string > (), 2); } +#line 787 "parser.cpp" + break; + + case 26: // exp: "identifier" "(" list ")" +#line 100 "..//parser.y" + { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } +#line 793 "parser.cpp" + break; + + case 27: // exp: "identifier" "[" indices_list "]" +#line 101 "..//parser.y" + { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 799 "parser.cpp" + break; + + case 28: // exp: "identifier" +#line 102 "..//parser.y" + { drv.createNode(yystack_[0].value.as < std::string > ()); } +#line 805 "parser.cpp" + break; + + case 29: // exp: "(" exp ")" +#line 103 "..//parser.y" + { } +#line 811 "parser.cpp" + break; + + case 30: // list: exp "," list +#line 107 "..//parser.y" + { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } +#line 817 "parser.cpp" + break; + + case 31: // list: exp +#line 108 "..//parser.y" + { yylhs.value.as < int > () = 1; } +#line 823 "parser.cpp" + break; + + case 32: // list: %empty +#line 109 "..//parser.y" + { yylhs.value.as < int > () = 0; } +#line 829 "parser.cpp" + break; + + +#line 833 "parser.cpp" + + default: + break; + } + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + YYERROR; + } +#endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhs); + yypop_ (yylen); + yylen = 0; + + // Shift the result of the reduction. + yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); + } + goto yynewstate; + + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + yyerrlab: + // If not already recovering from an error, report this error. + if (!yyerrstatus_) + { + ++yynerrs_; + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (yyla.location, YY_MOVE (msg)); + } + + + yyerror_range[1].location = yyla.location; + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + // Return failure if at end of input. + if (yyla.kind () == symbol_kind::S_YYEOF) + YYABORT; + else if (!yyla.empty ()) + { + yy_destroy_ ("Error: discarding", yyla); + yyla.clear (); + } + } + + // Else will try to reuse lookahead token after shifting the error token. + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and + the label yyerrorlab therefore never appears in user code. */ + if (false) + YYERROR; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + goto yyerrlab1; + + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; // Each real token shifted decrements this. + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += symbol_kind::S_YYerror; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == symbol_kind::S_YYerror) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; + + yyerror_range[1].location = yystack_[0].location; + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; + + yyerror_range[2].location = yyla.location; + YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); + + // Shift the error token. + yy_lac_discard_ ("error recovery"); + error_token.state = state_type (yyn); + yypush_ ("Shifting", YY_MOVE (error_token)); + } + goto yynewstate; + + + /*-------------------------------------. + | yyacceptlab -- YYACCEPT comes here. | + `-------------------------------------*/ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + + /*-----------------------------------. + | yyabortlab -- YYABORT comes here. | + `-----------------------------------*/ + yyabortlab: + yyresult = 1; + goto yyreturn; + + + /*-----------------------------------------------------. + | yyreturn -- parsing is finished, return the result. | + `-----------------------------------------------------*/ + yyreturn: + if (!yyla.empty ()) + yy_destroy_ ("Cleanup: discarding lookahead", yyla); + + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + YY_STACK_PRINT (); + while (1 < yystack_.size ()) + { + yy_destroy_ ("Cleanup: popping", yystack_[0]); + yypop_ (); + } + + return yyresult; + } +#if YY_EXCEPTIONS + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; + // Do not try to display the values of the reclaimed symbols, + // as their printers might throw an exception. + if (!yyla.empty ()) + yy_destroy_ (YY_NULLPTR, yyla); + + while (1 < yystack_.size ()) + { + yy_destroy_ (YY_NULLPTR, yystack_[0]); + yypop_ (); + } + throw; + } +#endif // YY_EXCEPTIONS + } + + void + parser::error (const syntax_error& yyexc) + { + error (yyexc.location, yyexc.what ()); + } + + const char * + parser::symbol_name (symbol_kind_type yysymbol) + { + static const char *const yy_sname[] = + { + "end of file", "error", "invalid token", ":=", ",", ":", "(", ")", "[", + "]", "\n", "var", "OPERATOR", "identifier", "VARNAME", "number", + "$accept", "unit", "assignments", "assignment", "indices_list", "index", + "exp", "list", YY_NULLPTR + }; + return yy_sname[yysymbol]; + } + + + + // parser::context. + parser::context::context (const parser& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + +#if YYDEBUG + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + if (!yyparser_.yy_lac_established_) + yyparser_.yy_lac_check_ (yyla_.kind ()); +#endif + + for (int yyx = 0; yyx < YYNTOKENS; ++yyx) + { + symbol_kind_type yysym = YY_CAST (symbol_kind_type, yyx); + if (yysym != symbol_kind::S_YYerror + && yysym != symbol_kind::S_YYUNDEF + && yyparser_.yy_lac_check_ (yysym)) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = symbol_kind::S_YYEMPTY; + return yycount; + } + + + + + bool + parser::yy_lac_check_ (symbol_kind_type yytoken) const + { + // Logically, the yylac_stack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + yylac_stack_.clear (); + // Reduce until we encounter a shift and thereby accept the token. +#if YYDEBUG + YYCDEBUG << "LAC: checking lookahead " << symbol_name (yytoken) << ':'; +#endif + std::ptrdiff_t lac_top = 0; + while (true) + { + state_type top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + int yyrule = yypact_[+top_state]; + if (yy_pact_value_is_default_ (yyrule) + || (yyrule += yytoken) < 0 || yylast_ < yyrule + || yycheck_[yyrule] != yytoken) + { + // Use the default action. + yyrule = yydefact_[+top_state]; + if (yyrule == 0) + { + YYCDEBUG << " Err\n"; + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yy_table_value_is_error_ (yyrule)) + { + YYCDEBUG << " Err\n"; + return false; + } + if (0 < yyrule) + { + YYCDEBUG << " S" << yyrule << '\n'; + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. + YYCDEBUG << " R" << yyrule - 1; + // Pop the corresponding number of values from the stack. + { + std::ptrdiff_t yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); + if (yylen < lac_size) + { + yylac_stack_.resize (std::size_t (lac_size - yylen)); + yylen = 0; + } + else if (lac_size) + { + yylac_stack_.clear (); + yylen -= lac_size; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lac_top. + lac_top += yylen; + } + // Keep top_state in sync with the updated stack. + top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + // Push the resulting state of the reduction. + state_type state = yy_lr_goto_state_ (top_state, yyr1_[yyrule]); + YYCDEBUG << " G" << int (state); + yylac_stack_.push_back (state); + } + } + + // Establish the initial context if no initial context currently exists. + bool + parser::yy_lac_establish_ (symbol_kind_type yytoken) + { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yy_lac_establish_ should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yy_lac_establish_ is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yy_lac_established_) + return true; + else + { +#if YYDEBUG + YYCDEBUG << "LAC: initial context established for " + << symbol_name (yytoken) << '\n'; +#endif + yy_lac_established_ = true; + return yy_lac_check_ (yytoken); + } + } + + // Discard any previous initial lookahead context. + void + parser::yy_lac_discard_ (const char* event) + { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yy_lac_established_) + { + YYCDEBUG << "LAC: initial context discarded due to " + << event << '\n'; + yy_lac_established_ = false; + } + } + + + int + parser::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when + yy_lac_check was invoked. However, at that time, there might + have been a different syntax error that discarded a different + initial context during error recovery, leaving behind the + current lookahead. + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + parser::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + } + + + const signed char parser::yypact_ninf_ = -6; + + const signed char parser::yytable_ninf_ = -1; + + const signed char + parser::yypact_[] = + { + 10, 15, 27, 4, 26, 22, -6, 4, 16, -6, + 21, 12, 10, -5, 4, -4, 4, 28, 29, -6, + -6, 8, 31, 0, 30, -1, -6, 21, -4, -4, + 4, -6, 19, 34, 1, -4, -6, 5, 14, -6, + -6, 25, 32, 36, -6, -6, -6, -6, -6, 33, + -6 + }; + + const signed char + parser::yydefact_[] = + { + 3, 0, 0, 0, 0, 0, 1, 0, 28, 24, + 2, 0, 3, 0, 32, 11, 0, 6, 5, 4, + 29, 31, 0, 0, 22, 0, 10, 25, 11, 11, + 32, 26, 0, 19, 21, 23, 27, 0, 0, 30, + 17, 18, 20, 16, 9, 8, 7, 13, 14, 15, + 12 + }; + + const signed char + parser::yypgoto_[] = + { + -6, -6, 37, -6, 2, 7, -3, 13 + }; + + const signed char + parser::yydefgoto_[] = + { + 0, 2, 3, 5, 25, 26, 21, 22 + }; + + const signed char + parser::yytable_[] = + { + 10, 23, 20, 35, 13, 32, 42, 16, 36, 35, + 7, 24, 30, 27, 45, 33, 43, 8, 35, 9, + 16, 1, 14, 46, 15, 17, 18, 6, 4, 11, + 37, 38, 12, 16, 40, 34, 28, 29, 31, 41, + 47, 49, 44, 39, 0, 0, 0, 48, 50, 19 + }; + + const signed char + parser::yycheck_[] = + { + 3, 5, 7, 4, 7, 5, 5, 12, 9, 4, + 6, 15, 4, 16, 9, 15, 15, 13, 4, 15, + 12, 11, 6, 9, 8, 13, 14, 0, 13, 3, + 28, 29, 10, 12, 15, 5, 8, 8, 7, 5, + 15, 5, 35, 30, -1, -1, -1, 15, 15, 12 + }; + + const signed char + parser::yystos_[] = + { + 0, 11, 17, 18, 13, 19, 0, 6, 13, 15, + 22, 3, 10, 22, 6, 8, 12, 13, 14, 18, + 7, 22, 23, 5, 15, 20, 21, 22, 8, 8, + 4, 7, 5, 15, 5, 4, 9, 20, 20, 23, + 15, 5, 5, 15, 21, 9, 9, 15, 15, 5, + 15 + }; + + const signed char + parser::yyr1_[] = + { + 0, 16, 17, 18, 18, 19, 19, 19, 19, 20, + 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, + 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, + 23, 23, 23 + }; + + const signed char + parser::yyr2_[] = + { + 0, 2, 2, 0, 4, 3, 3, 6, 6, 3, + 1, 0, 5, 4, 4, 4, 3, 3, 3, 2, + 3, 2, 1, 0, 1, 3, 4, 4, 1, 3, + 3, 1, 0 + }; + + + + +#if YYDEBUG + const signed char + parser::yyrline_[] = + { + 0, 65, 65, 68, 69, 72, 73, 74, 75, 78, + 79, 80, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 98, 99, 100, 101, 102, 103, + 107, 108, 109 + }; + + void + parser::yy_stack_print_ () const + { + *yycdebug_ << "Stack now"; + for (stack_type::const_iterator + i = yystack_.begin (), + i_end = yystack_.end (); + i != i_end; ++i) + *yycdebug_ << ' ' << int (i->state); + *yycdebug_ << '\n'; + } + + void + parser::yy_reduce_print_ (int yyrule) const + { + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + // Print the symbols being reduced, and their result. + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):\n"; + // The symbols being reduced. + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + yystack_[(yynrhs) - (yyi + 1)]); + } +#endif // YYDEBUG + + +#line 6 "..//parser.y" +} } // adios2::detail +#line 1419 "parser.cpp" + +#line 110 "..//parser.y" + + +void +adios2::detail::parser::error (const location_type& l, const std::string& m) +{ + std::cerr << l << ": " << m << '\n'; +} diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/parser.h new file mode 100644 index 0000000000..340f7ba54c --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.h @@ -0,0 +1,1643 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Skeleton interface for Bison LALR(1) parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + + +/** + ** \file parser.h + ** Define the adios2::detail::parser class. + */ + +// C++ LALR(1) parser skeleton written by Akim Demaille. + +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. + +#ifndef YY_YY_PARSER_H_INCLUDED +# define YY_YY_PARSER_H_INCLUDED +// "%code requires" blocks. +#line 11 "..//parser.y" + + #include + #include + #include + class ASTDriver; + +#line 56 "parser.h" + +# include +# include // std::abort +# include +# include +# include +# include + +#if defined __cplusplus +# define YY_CPLUSPLUS __cplusplus +#else +# define YY_CPLUSPLUS 199711L +#endif + +// Support move semantics when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_MOVE std::move +# define YY_MOVE_OR_COPY move +# define YY_MOVE_REF(Type) Type&& +# define YY_RVREF(Type) Type&& +# define YY_COPY(Type) Type +#else +# define YY_MOVE +# define YY_MOVE_OR_COPY copy +# define YY_MOVE_REF(Type) Type& +# define YY_RVREF(Type) const Type& +# define YY_COPY(Type) const Type& +#endif + +// Support noexcept when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_NOEXCEPT noexcept +# define YY_NOTHROW +#else +# define YY_NOEXCEPT +# define YY_NOTHROW throw () +#endif + +// Support constexpr when possible. +#if 201703 <= YY_CPLUSPLUS +# define YY_CONSTEXPR constexpr +#else +# define YY_CONSTEXPR +#endif +# include "location.hh" +#include +#ifndef YY_ASSERT +# include +# define YY_ASSERT assert +#endif + + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 1 +#endif + +#line 6 "..//parser.y" +namespace adios2 { namespace detail { +#line 197 "parser.h" + + + + + /// A Bison parser. + class parser + { + public: +#ifdef YYSTYPE +# ifdef __GNUC__ +# pragma GCC message "bison: do not #define YYSTYPE in C++, use %define api.value.type" +# endif + typedef YYSTYPE value_type; +#else + /// A buffer to store and retrieve objects. + /// + /// Sort of a variant, but does not keep track of the nature + /// of the stored data, since that knowledge is available + /// via the current parser state. + class value_type + { + public: + /// Type of *this. + typedef value_type self_type; + + /// Empty construction. + value_type () YY_NOEXCEPT + : yyraw_ () + , yytypeid_ (YY_NULLPTR) + {} + + /// Construct and fill. + template + value_type (YY_RVREF (T) t) + : yytypeid_ (&typeid (T)) + { + YY_ASSERT (sizeof (T) <= size); + new (yyas_ ()) T (YY_MOVE (t)); + } + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + value_type (const self_type&) = delete; + /// Non copyable. + self_type& operator= (const self_type&) = delete; +#endif + + /// Destruction, allowed only if empty. + ~value_type () YY_NOEXCEPT + { + YY_ASSERT (!yytypeid_); + } + +# if 201103L <= YY_CPLUSPLUS + /// Instantiate a \a T in here from \a t. + template + T& + emplace (U&&... u) + { + YY_ASSERT (!yytypeid_); + YY_ASSERT (sizeof (T) <= size); + yytypeid_ = & typeid (T); + return *new (yyas_ ()) T (std::forward (u)...); + } +# else + /// Instantiate an empty \a T in here. + template + T& + emplace () + { + YY_ASSERT (!yytypeid_); + YY_ASSERT (sizeof (T) <= size); + yytypeid_ = & typeid (T); + return *new (yyas_ ()) T (); + } + + /// Instantiate a \a T in here from \a t. + template + T& + emplace (const T& t) + { + YY_ASSERT (!yytypeid_); + YY_ASSERT (sizeof (T) <= size); + yytypeid_ = & typeid (T); + return *new (yyas_ ()) T (t); + } +# endif + + /// Instantiate an empty \a T in here. + /// Obsolete, use emplace. + template + T& + build () + { + return emplace (); + } + + /// Instantiate a \a T in here from \a t. + /// Obsolete, use emplace. + template + T& + build (const T& t) + { + return emplace (t); + } + + /// Accessor to a built \a T. + template + T& + as () YY_NOEXCEPT + { + YY_ASSERT (yytypeid_); + YY_ASSERT (*yytypeid_ == typeid (T)); + YY_ASSERT (sizeof (T) <= size); + return *yyas_ (); + } + + /// Const accessor to a built \a T (for %printer). + template + const T& + as () const YY_NOEXCEPT + { + YY_ASSERT (yytypeid_); + YY_ASSERT (*yytypeid_ == typeid (T)); + YY_ASSERT (sizeof (T) <= size); + return *yyas_ (); + } + + /// Swap the content with \a that, of same type. + /// + /// Both variants must be built beforehand, because swapping the actual + /// data requires reading it (with as()), and this is not possible on + /// unconstructed variants: it would require some dynamic testing, which + /// should not be the variant's responsibility. + /// Swapping between built and (possibly) non-built is done with + /// self_type::move (). + template + void + swap (self_type& that) YY_NOEXCEPT + { + YY_ASSERT (yytypeid_); + YY_ASSERT (*yytypeid_ == *that.yytypeid_); + std::swap (as (), that.as ()); + } + + /// Move the content of \a that to this. + /// + /// Destroys \a that. + template + void + move (self_type& that) + { +# if 201103L <= YY_CPLUSPLUS + emplace (std::move (that.as ())); +# else + emplace (); + swap (that); +# endif + that.destroy (); + } + +# if 201103L <= YY_CPLUSPLUS + /// Move the content of \a that to this. + template + void + move (self_type&& that) + { + emplace (std::move (that.as ())); + that.destroy (); + } +#endif + + /// Copy the content of \a that to this. + template + void + copy (const self_type& that) + { + emplace (that.as ()); + } + + /// Destroy the stored \a T. + template + void + destroy () + { + as ().~T (); + yytypeid_ = YY_NULLPTR; + } + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + value_type (const self_type&); + /// Non copyable. + self_type& operator= (const self_type&); +#endif + + /// Accessor to raw memory as \a T. + template + T* + yyas_ () YY_NOEXCEPT + { + void *yyp = yyraw_; + return static_cast (yyp); + } + + /// Const accessor to raw memory as \a T. + template + const T* + yyas_ () const YY_NOEXCEPT + { + const void *yyp = yyraw_; + return static_cast (yyp); + } + + /// An auxiliary type to compute the largest semantic type. + union union_type + { + // "number" + // exp + // list + char dummy1[sizeof (int)]; + + // OPERATOR + // "identifier" + // VARNAME + char dummy2[sizeof (std::string)]; + + // index + char dummy3[sizeof (std::tuple)]; + + // indices_list + char dummy4[sizeof (std::vector>)]; + }; + + /// The size of the largest semantic type. + enum { size = sizeof (union_type) }; + + /// A buffer to store semantic values. + union + { + /// Strongest alignment constraints. + long double yyalign_me_; + /// A buffer large enough to store any of the semantic values. + char yyraw_[size]; + }; + + /// Whether the content is built: if defined, the name of the stored type. + const std::type_info *yytypeid_; + }; + +#endif + /// Backward compatibility (Bison 3.8). + typedef value_type semantic_type; + + /// Symbol locations. + typedef location location_type; + + /// Syntax errors thrown from user actions. + struct syntax_error : std::runtime_error + { + syntax_error (const location_type& l, const std::string& m) + : std::runtime_error (m) + , location (l) + {} + + syntax_error (const syntax_error& s) + : std::runtime_error (s.what ()) + , location (s.location) + {} + + ~syntax_error () YY_NOEXCEPT YY_NOTHROW; + + location_type location; + }; + + /// Token kinds. + struct token + { + enum token_kind_type + { + TOK_YYEMPTY = -2, + TOK_YYEOF = 0, // "end of file" + TOK_YYerror = 1, // error + TOK_YYUNDEF = 2, // "invalid token" + TOK_ASSIGN = 3, // ":=" + TOK_COMMA = 4, // "," + TOK_COLON = 5, // ":" + TOK_L_PAREN = 6, // "(" + TOK_R_PAREN = 7, // ")" + TOK_L_BRACE = 8, // "[" + TOK_R_BRACE = 9, // "]" + TOK_ENDL = 10, // "\n" + TOK_VAR = 11, // "var" + TOK_OPERATOR = 12, // OPERATOR + TOK_IDENTIFIER = 13, // "identifier" + TOK_VARNAME = 14, // VARNAME + TOK_INT = 15 // "number" + }; + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type yytokentype; + }; + + /// Token kind, as returned by yylex. + typedef token::token_kind_type token_kind_type; + + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type token_type; + + /// Symbol kinds. + struct symbol_kind + { + enum symbol_kind_type + { + YYNTOKENS = 16, ///< Number of tokens. + S_YYEMPTY = -2, + S_YYEOF = 0, // "end of file" + S_YYerror = 1, // error + S_YYUNDEF = 2, // "invalid token" + S_ASSIGN = 3, // ":=" + S_COMMA = 4, // "," + S_COLON = 5, // ":" + S_L_PAREN = 6, // "(" + S_R_PAREN = 7, // ")" + S_L_BRACE = 8, // "[" + S_R_BRACE = 9, // "]" + S_ENDL = 10, // "\n" + S_VAR = 11, // "var" + S_OPERATOR = 12, // OPERATOR + S_IDENTIFIER = 13, // "identifier" + S_VARNAME = 14, // VARNAME + S_INT = 15, // "number" + S_YYACCEPT = 16, // $accept + S_unit = 17, // unit + S_assignments = 18, // assignments + S_assignment = 19, // assignment + S_indices_list = 20, // indices_list + S_index = 21, // index + S_exp = 22, // exp + S_list = 23 // list + }; + }; + + /// (Internal) symbol kind. + typedef symbol_kind::symbol_kind_type symbol_kind_type; + + /// The number of tokens. + static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; + + /// A complete symbol. + /// + /// Expects its Base type to provide access to the symbol kind + /// via kind (). + /// + /// Provide access to semantic value and location. + template + struct basic_symbol : Base + { + /// Alias to Base. + typedef Base super_type; + + /// Default constructor. + basic_symbol () YY_NOEXCEPT + : value () + , location () + {} + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + basic_symbol (basic_symbol&& that) + : Base (std::move (that)) + , value () + , location (std::move (that.location)) + { + switch (this->kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.move< int > (std::move (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (std::move (that.value)); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (std::move (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (std::move (that.value)); + break; + + default: + break; + } + + } +#endif + + /// Copy constructor. + basic_symbol (const basic_symbol& that); + + /// Constructors for typed symbols. +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, location_type&& l) + : Base (t) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const location_type& l) + : Base (t) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, int&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const int& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, std::tuple&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const std::tuple& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, std::vector>&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const std::vector>& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + + /// Destroy the symbol. + ~basic_symbol () + { + clear (); + } + + + + /// Destroy contents, and record that is empty. + void clear () YY_NOEXCEPT + { + // User destructor. + symbol_kind_type yykind = this->kind (); + basic_symbol& yysym = *this; + (void) yysym; + switch (yykind) + { + default: + break; + } + + // Value type destructor. +switch (yykind) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.template destroy< int > (); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.template destroy< std::string > (); + break; + + case symbol_kind::S_index: // index + value.template destroy< std::tuple > (); + break; + + case symbol_kind::S_indices_list: // indices_list + value.template destroy< std::vector> > (); + break; + + default: + break; + } + + Base::clear (); + } + + /// The user-facing name of this symbol. + const char *name () const YY_NOEXCEPT + { + return parser::symbol_name (this->kind ()); + } + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + + /// Whether empty. + bool empty () const YY_NOEXCEPT; + + /// Destructive move, \a s is emptied into this. + void move (basic_symbol& s); + + /// The semantic value. + value_type value; + + /// The location. + location_type location; + + private: +#if YY_CPLUSPLUS < 201103L + /// Assignment operator. + basic_symbol& operator= (const basic_symbol& that); +#endif + }; + + /// Type access provider for token (enum) based symbols. + struct by_kind + { + /// The symbol kind as needed by the constructor. + typedef token_kind_type kind_type; + + /// Default constructor. + by_kind () YY_NOEXCEPT; + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + by_kind (by_kind&& that) YY_NOEXCEPT; +#endif + + /// Copy constructor. + by_kind (const by_kind& that) YY_NOEXCEPT; + + /// Constructor from (external) token numbers. + by_kind (kind_type t) YY_NOEXCEPT; + + + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_kind& that); + + /// The (internal) type number (corresponding to \a type). + /// \a empty when empty. + symbol_kind_type kind () const YY_NOEXCEPT; + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + + /// The symbol kind. + /// \a S_YYEMPTY when empty. + symbol_kind_type kind_; + }; + + /// Backward compatibility for a private implementation detail (Bison 3.6). + typedef by_kind by_type; + + /// "External" symbols: returned by the scanner. + struct symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + + /// Empty symbol. + symbol_type () YY_NOEXCEPT {} + + /// Constructor for valueless symbols, and symbols from each type. +#if 201103L <= YY_CPLUSPLUS + symbol_type (int tok, location_type l) + : super_type (token_kind_type (tok), std::move (l)) +#else + symbol_type (int tok, const location_type& l) + : super_type (token_kind_type (tok), l) +#endif + { +#if !defined _MSC_VER || defined __clang__ + YY_ASSERT (tok == token::TOK_YYEOF + || (token::TOK_YYerror <= tok && tok <= token::TOK_VAR)); +#endif + } +#if 201103L <= YY_CPLUSPLUS + symbol_type (int tok, int v, location_type l) + : super_type (token_kind_type (tok), std::move (v), std::move (l)) +#else + symbol_type (int tok, const int& v, const location_type& l) + : super_type (token_kind_type (tok), v, l) +#endif + { +#if !defined _MSC_VER || defined __clang__ + YY_ASSERT (tok == token::TOK_INT); +#endif + } +#if 201103L <= YY_CPLUSPLUS + symbol_type (int tok, std::string v, location_type l) + : super_type (token_kind_type (tok), std::move (v), std::move (l)) +#else + symbol_type (int tok, const std::string& v, const location_type& l) + : super_type (token_kind_type (tok), v, l) +#endif + { +#if !defined _MSC_VER || defined __clang__ + YY_ASSERT ((token::TOK_OPERATOR <= tok && tok <= token::TOK_VARNAME)); +#endif + } + }; + + /// Build a parser object. + parser (ASTDriver& drv_yyarg); + virtual ~parser (); + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + parser (const parser&) = delete; + /// Non copyable. + parser& operator= (const parser&) = delete; +#endif + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if YYDEBUG + /// The current debugging stream. + std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const YY_ATTRIBUTE_PURE; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error. + /// \param loc where the syntax error is found. + /// \param msg a description of the syntax error. + virtual void error (const location_type& loc, const std::string& msg); + + /// Report a syntax error. + void error (const syntax_error& err); + + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol); + + // Implementation of make_symbol for each token kind. +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_YYEOF (location_type l) + { + return symbol_type (token::TOK_YYEOF, std::move (l)); + } +#else + static + symbol_type + make_YYEOF (const location_type& l) + { + return symbol_type (token::TOK_YYEOF, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_YYerror (location_type l) + { + return symbol_type (token::TOK_YYerror, std::move (l)); + } +#else + static + symbol_type + make_YYerror (const location_type& l) + { + return symbol_type (token::TOK_YYerror, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_YYUNDEF (location_type l) + { + return symbol_type (token::TOK_YYUNDEF, std::move (l)); + } +#else + static + symbol_type + make_YYUNDEF (const location_type& l) + { + return symbol_type (token::TOK_YYUNDEF, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_ASSIGN (location_type l) + { + return symbol_type (token::TOK_ASSIGN, std::move (l)); + } +#else + static + symbol_type + make_ASSIGN (const location_type& l) + { + return symbol_type (token::TOK_ASSIGN, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_COMMA (location_type l) + { + return symbol_type (token::TOK_COMMA, std::move (l)); + } +#else + static + symbol_type + make_COMMA (const location_type& l) + { + return symbol_type (token::TOK_COMMA, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_COLON (location_type l) + { + return symbol_type (token::TOK_COLON, std::move (l)); + } +#else + static + symbol_type + make_COLON (const location_type& l) + { + return symbol_type (token::TOK_COLON, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_L_PAREN (location_type l) + { + return symbol_type (token::TOK_L_PAREN, std::move (l)); + } +#else + static + symbol_type + make_L_PAREN (const location_type& l) + { + return symbol_type (token::TOK_L_PAREN, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_R_PAREN (location_type l) + { + return symbol_type (token::TOK_R_PAREN, std::move (l)); + } +#else + static + symbol_type + make_R_PAREN (const location_type& l) + { + return symbol_type (token::TOK_R_PAREN, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_L_BRACE (location_type l) + { + return symbol_type (token::TOK_L_BRACE, std::move (l)); + } +#else + static + symbol_type + make_L_BRACE (const location_type& l) + { + return symbol_type (token::TOK_L_BRACE, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_R_BRACE (location_type l) + { + return symbol_type (token::TOK_R_BRACE, std::move (l)); + } +#else + static + symbol_type + make_R_BRACE (const location_type& l) + { + return symbol_type (token::TOK_R_BRACE, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_ENDL (location_type l) + { + return symbol_type (token::TOK_ENDL, std::move (l)); + } +#else + static + symbol_type + make_ENDL (const location_type& l) + { + return symbol_type (token::TOK_ENDL, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_VAR (location_type l) + { + return symbol_type (token::TOK_VAR, std::move (l)); + } +#else + static + symbol_type + make_VAR (const location_type& l) + { + return symbol_type (token::TOK_VAR, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_OPERATOR (std::string v, location_type l) + { + return symbol_type (token::TOK_OPERATOR, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_OPERATOR (const std::string& v, const location_type& l) + { + return symbol_type (token::TOK_OPERATOR, v, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_IDENTIFIER (std::string v, location_type l) + { + return symbol_type (token::TOK_IDENTIFIER, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_IDENTIFIER (const std::string& v, const location_type& l) + { + return symbol_type (token::TOK_IDENTIFIER, v, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_VARNAME (std::string v, location_type l) + { + return symbol_type (token::TOK_VARNAME, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_VARNAME (const std::string& v, const location_type& l) + { + return symbol_type (token::TOK_VARNAME, v, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_INT (int v, location_type l) + { + return symbol_type (token::TOK_INT, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_INT (const int& v, const location_type& l) + { + return symbol_type (token::TOK_INT, v, l); + } +#endif + + + class context + { + public: + context (const parser& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); } + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } + + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const parser& yyparser_; + const symbol_type& yyla_; + }; + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + parser (const parser&); + /// Non copyable. + parser& operator= (const parser&); +#endif + + /// Check the lookahead yytoken. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_check_ (symbol_kind_type yytoken) const; + /// Establish the initial context if no initial context currently exists. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_establish_ (symbol_kind_type yytoken); + /// Discard any previous initial lookahead context because of event. + /// \param event the event which caused the lookahead to be discarded. + /// Only used for debbuging output. + void yy_lac_discard_ (const char* event); + + /// Stored state numbers (used for stacks). + typedef signed char state_type; + + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const; + /// Compute post-reduction state. + /// \param yystate the current state + /// \param yysym the nonterminal to push on the stack + static state_type yy_lr_goto_state_ (state_type yystate, int yysym); + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT; + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT; + + static const signed char yypact_ninf_; + static const signed char yytable_ninf_; + + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals + /// are valid, yet not members of the token_kind_type enum. + static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; + + + + // Tables. + // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + // STATE-NUM. + static const signed char yypact_[]; + + // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + // Performed when YYTABLE does not specify something else to do. Zero + // means the default is an error. + static const signed char yydefact_[]; + + // YYPGOTO[NTERM-NUM]. + static const signed char yypgoto_[]; + + // YYDEFGOTO[NTERM-NUM]. + static const signed char yydefgoto_[]; + + // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + // positive, shift that token. If negative, reduce the rule whose + // number is the opposite. If YYTABLE_NINF, syntax error. + static const signed char yytable_[]; + + static const signed char yycheck_[]; + + // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + // state STATE-NUM. + static const signed char yystos_[]; + + // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. + static const signed char yyr1_[]; + + // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. + static const signed char yyr2_[]; + + +#if YYDEBUG + // YYRLINE[YYN] -- Source line where rule number YYN was defined. + static const signed char yyrline_[]; + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r) const; + /// Print the state stack on the debug stream. + virtual void yy_stack_print_ () const; + + /// Debugging level. + int yydebug_; + /// Debug stream. + std::ostream* yycdebug_; + + /// \brief Display a symbol kind, value and location. + /// \param yyo The output stream. + /// \param yysym The symbol. + template + void yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const; +#endif + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param yysym The symbol. + template + void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; + + private: + /// Type access provider for state based symbols. + struct by_state + { + /// Default constructor. + by_state () YY_NOEXCEPT; + + /// The symbol kind as needed by the constructor. + typedef state_type kind_type; + + /// Constructor. + by_state (kind_type s) YY_NOEXCEPT; + + /// Copy constructor. + by_state (const by_state& that) YY_NOEXCEPT; + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_state& that); + + /// The symbol kind (corresponding to \a state). + /// \a symbol_kind::S_YYEMPTY when empty. + symbol_kind_type kind () const YY_NOEXCEPT; + + /// The state number used to denote an empty symbol. + /// We use the initial state, as it does not have a value. + enum { empty_state = 0 }; + + /// The state. + /// \a empty when empty. + state_type state; + }; + + /// "Internal" symbol: element of the stack. + struct stack_symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + /// Construct an empty symbol. + stack_symbol_type (); + /// Move or copy construction. + stack_symbol_type (YY_RVREF (stack_symbol_type) that); + /// Steal the contents from \a sym to build this. + stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); +#if YY_CPLUSPLUS < 201103L + /// Assignment, needed by push_back by some old implementations. + /// Moves the contents of that. + stack_symbol_type& operator= (stack_symbol_type& that); + + /// Assignment, needed by push_back by other implementations. + /// Needed by some other old implementations. + stack_symbol_type& operator= (const stack_symbol_type& that); +#endif + }; + + /// A stack with random access from its top. + template > + class stack + { + public: + // Hide our reversed order. + typedef typename S::iterator iterator; + typedef typename S::const_iterator const_iterator; + typedef typename S::size_type size_type; + typedef typename std::ptrdiff_t index_type; + + stack (size_type n = 200) YY_NOEXCEPT + : seq_ (n) + {} + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + stack (const stack&) = delete; + /// Non copyable. + stack& operator= (const stack&) = delete; +#endif + + /// Random access. + /// + /// Index 0 returns the topmost element. + const T& + operator[] (index_type i) const + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Random access. + /// + /// Index 0 returns the topmost element. + T& + operator[] (index_type i) + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Steal the contents of \a t. + /// + /// Close to move-semantics. + void + push (YY_MOVE_REF (T) t) + { + seq_.push_back (T ()); + operator[] (0).move (t); + } + + /// Pop elements from the stack. + void + pop (std::ptrdiff_t n = 1) YY_NOEXCEPT + { + for (; 0 < n; --n) + seq_.pop_back (); + } + + /// Pop all elements from the stack. + void + clear () YY_NOEXCEPT + { + seq_.clear (); + } + + /// Number of elements on the stack. + index_type + size () const YY_NOEXCEPT + { + return index_type (seq_.size ()); + } + + /// Iterator on top of the stack (going downwards). + const_iterator + begin () const YY_NOEXCEPT + { + return seq_.begin (); + } + + /// Bottom of the stack. + const_iterator + end () const YY_NOEXCEPT + { + return seq_.end (); + } + + /// Present a slice of the top of a stack. + class slice + { + public: + slice (const stack& stack, index_type range) YY_NOEXCEPT + : stack_ (stack) + , range_ (range) + {} + + const T& + operator[] (index_type i) const + { + return stack_[range_ - i]; + } + + private: + const stack& stack_; + index_type range_; + }; + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + stack (const stack&); + /// Non copyable. + stack& operator= (const stack&); +#endif + /// The wrapped container. + S seq_; + }; + + + /// Stack type. + typedef stack stack_type; + + /// The stack. + stack_type yystack_; + /// The stack for LAC. + /// Logically, the yy_lac_stack's lifetime is confined to the function + /// yy_lac_check_. We just store it as a member of this class to hold + /// on to the memory and to avoid frequent reallocations. + /// Since yy_lac_check_ is const, this member must be mutable. + mutable std::vector yylac_stack_; + /// Whether an initial LAC context was established. + bool yy_lac_established_; + + + /// Push a new state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param sym the symbol + /// \warning the contents of \a s.value is stolen. + void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); + + /// Push a new look ahead token on the state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param s the state + /// \param sym the symbol (for its value and location). + /// \warning the contents of \a sym.value is stolen. + void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); + + /// Pop \a n symbols from the stack. + void yypop_ (int n = 1) YY_NOEXCEPT; + + /// Constants. + enum + { + yylast_ = 49, ///< Last index in yytable_. + yynnts_ = 8, ///< Number of nonterminal symbols. + yyfinal_ = 6 ///< Termination state number. + }; + + + // User arguments. + ASTDriver& drv; + + }; + + inline + parser::symbol_kind_type + parser::yytranslate_ (int t) YY_NOEXCEPT + { + return static_cast (t); + } + + // basic_symbol. + template + parser::basic_symbol::basic_symbol (const basic_symbol& that) + : Base (that) + , value () + , location (that.location) + { + switch (this->kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.copy< int > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.copy< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_index: // index + value.copy< std::tuple > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.copy< std::vector> > (YY_MOVE (that.value)); + break; + + default: + break; + } + + } + + + + + template + parser::symbol_kind_type + parser::basic_symbol::type_get () const YY_NOEXCEPT + { + return this->kind (); + } + + + template + bool + parser::basic_symbol::empty () const YY_NOEXCEPT + { + return this->kind () == symbol_kind::S_YYEMPTY; + } + + template + void + parser::basic_symbol::move (basic_symbol& s) + { + super_type::move (s); + switch (this->kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_exp: // exp + case symbol_kind::S_list: // list + value.move< int > (YY_MOVE (s.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (YY_MOVE (s.value)); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (YY_MOVE (s.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (YY_MOVE (s.value)); + break; + + default: + break; + } + + location = YY_MOVE (s.location); + } + + // by_kind. + inline + parser::by_kind::by_kind () YY_NOEXCEPT + : kind_ (symbol_kind::S_YYEMPTY) + {} + +#if 201103L <= YY_CPLUSPLUS + inline + parser::by_kind::by_kind (by_kind&& that) YY_NOEXCEPT + : kind_ (that.kind_) + { + that.clear (); + } +#endif + + inline + parser::by_kind::by_kind (const by_kind& that) YY_NOEXCEPT + : kind_ (that.kind_) + {} + + inline + parser::by_kind::by_kind (token_kind_type t) YY_NOEXCEPT + : kind_ (yytranslate_ (t)) + {} + + + + inline + void + parser::by_kind::clear () YY_NOEXCEPT + { + kind_ = symbol_kind::S_YYEMPTY; + } + + inline + void + parser::by_kind::move (by_kind& that) + { + kind_ = that.kind_; + that.clear (); + } + + inline + parser::symbol_kind_type + parser::by_kind::kind () const YY_NOEXCEPT + { + return kind_; + } + + + inline + parser::symbol_kind_type + parser::by_kind::type_get () const YY_NOEXCEPT + { + return this->kind (); + } + + +#line 6 "..//parser.y" +} } // adios2::detail +#line 1639 "parser.h" + + + + +#endif // !YY_YY_PARSER_H_INCLUDED diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.output b/source/adios2/toolkit/derived/parser/pregen-source/parser.output new file mode 100644 index 0000000000..9b5e1a36a1 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.output @@ -0,0 +1,597 @@ +State 15 conflicts: 2 reduce/reduce +State 27 conflicts: 1 shift/reduce +State 28 conflicts: 2 reduce/reduce +State 29 conflicts: 2 reduce/reduce + + +Grammar + + 0 $accept: unit $end + + 1 unit: assignments exp + + 2 assignments: ε + 3 | "var" assignment "\n" assignments + + 4 assignment: "identifier" ":=" VARNAME + 5 | "identifier" ":=" "identifier" + 6 | "identifier" ":=" VARNAME "[" indices_list "]" + 7 | "identifier" ":=" "identifier" "[" indices_list "]" + + 8 indices_list: indices_list "," index + 9 | index + 10 | ε + + 11 index: "number" ":" "number" ":" "number" + 12 | ":" "number" ":" "number" + 13 | "number" ":" ":" "number" + 14 | "number" ":" "number" ":" + 15 | "number" ":" "number" + 16 | ":" ":" "number" + 17 | ":" "number" ":" + 18 | ":" "number" + 19 | "number" ":" ":" + 20 | "number" ":" + 21 | "number" + 22 | ε + + 23 exp: "number" + 24 | exp OPERATOR exp + 25 | "identifier" "(" list ")" + 26 | "identifier" "[" indices_list "]" + 27 | "identifier" + 28 | "(" exp ")" + + 29 list: exp "," list + 30 | exp + 31 | ε + + +Terminals, with rules where they appear + + $end (0) 0 + error (256) + ":=" (258) 4 5 6 7 + "," (259) 8 29 + ":" (260) 11 12 13 14 15 16 17 18 19 20 + "(" (261) 25 28 + ")" (262) 25 28 + "[" (263) 6 7 26 + "]" (264) 6 7 26 + "\n" (265) 3 + "var" (266) 3 + OPERATOR (267) 24 + "identifier" (268) 4 5 6 7 25 26 27 + VARNAME (269) 4 6 + "number" (270) 11 12 13 14 15 16 17 18 19 20 21 23 + + +Nonterminals, with rules where they appear + + $accept (16) + on left: 0 + unit (17) + on left: 1 + on right: 0 + assignments (18) + on left: 2 3 + on right: 1 3 + assignment (19) + on left: 4 5 6 7 + on right: 3 + indices_list >> (20) + on left: 8 9 10 + on right: 6 7 8 26 + index > (21) + on left: 11 12 13 14 15 16 17 18 19 20 21 22 + on right: 8 9 + exp (22) + on left: 23 24 25 26 27 28 + on right: 1 24 28 29 30 + list (23) + on left: 29 30 31 + on right: 25 29 + + +State 0 + + 0 $accept: • unit $end + + "var" shift, and go to state 1 + + $default reduce using rule 2 (assignments) + + unit go to state 2 + assignments go to state 3 + + +State 1 + + 3 assignments: "var" • assignment "\n" assignments + + "identifier" shift, and go to state 4 + + assignment go to state 5 + + +State 2 + + 0 $accept: unit • $end + + $end shift, and go to state 6 + + +State 3 + + 1 unit: assignments • exp + + "(" shift, and go to state 7 + "identifier" shift, and go to state 8 + "number" shift, and go to state 9 + + exp go to state 10 + + +State 4 + + 4 assignment: "identifier" • ":=" VARNAME + 5 | "identifier" • ":=" "identifier" + 6 | "identifier" • ":=" VARNAME "[" indices_list "]" + 7 | "identifier" • ":=" "identifier" "[" indices_list "]" + + ":=" shift, and go to state 11 + + +State 5 + + 3 assignments: "var" assignment • "\n" assignments + + "\n" shift, and go to state 12 + + +State 6 + + 0 $accept: unit $end • + + $default accept + + +State 7 + + 28 exp: "(" • exp ")" + + "(" shift, and go to state 7 + "identifier" shift, and go to state 8 + "number" shift, and go to state 9 + + exp go to state 13 + + +State 8 + + 25 exp: "identifier" • "(" list ")" + 26 | "identifier" • "[" indices_list "]" + 27 | "identifier" • + + "(" shift, and go to state 14 + "[" shift, and go to state 15 + + $default reduce using rule 27 (exp) + + +State 9 + + 23 exp: "number" • + + $default reduce using rule 23 (exp) + + +State 10 + + 1 unit: assignments exp • + 24 exp: exp • OPERATOR exp + + OPERATOR shift, and go to state 16 + + $default reduce using rule 1 (unit) + + +State 11 + + 4 assignment: "identifier" ":=" • VARNAME + 5 | "identifier" ":=" • "identifier" + 6 | "identifier" ":=" • VARNAME "[" indices_list "]" + 7 | "identifier" ":=" • "identifier" "[" indices_list "]" + + "identifier" shift, and go to state 17 + VARNAME shift, and go to state 18 + + +State 12 + + 3 assignments: "var" assignment "\n" • assignments + + "var" shift, and go to state 1 + + $default reduce using rule 2 (assignments) + + assignments go to state 19 + + +State 13 + + 24 exp: exp • OPERATOR exp + 28 | "(" exp • ")" + + ")" shift, and go to state 20 + OPERATOR shift, and go to state 16 + + +State 14 + + 25 exp: "identifier" "(" • list ")" + + "(" shift, and go to state 7 + "identifier" shift, and go to state 8 + "number" shift, and go to state 9 + + $default reduce using rule 31 (list) + + exp go to state 21 + list go to state 22 + + +State 15 + + 26 exp: "identifier" "[" • indices_list "]" + + ":" shift, and go to state 23 + "number" shift, and go to state 24 + + "," reduce using rule 10 (indices_list) + "," [reduce using rule 22 (index)] + "]" reduce using rule 10 (indices_list) + "]" [reduce using rule 22 (index)] + $default reduce using rule 10 (indices_list) + + indices_list go to state 25 + index go to state 26 + + +State 16 + + 24 exp: exp OPERATOR • exp + + "(" shift, and go to state 7 + "identifier" shift, and go to state 8 + "number" shift, and go to state 9 + + exp go to state 27 + + +State 17 + + 5 assignment: "identifier" ":=" "identifier" • + 7 | "identifier" ":=" "identifier" • "[" indices_list "]" + + "[" shift, and go to state 28 + + $default reduce using rule 5 (assignment) + + +State 18 + + 4 assignment: "identifier" ":=" VARNAME • + 6 | "identifier" ":=" VARNAME • "[" indices_list "]" + + "[" shift, and go to state 29 + + $default reduce using rule 4 (assignment) + + +State 19 + + 3 assignments: "var" assignment "\n" assignments • + + $default reduce using rule 3 (assignments) + + +State 20 + + 28 exp: "(" exp ")" • + + $default reduce using rule 28 (exp) + + +State 21 + + 24 exp: exp • OPERATOR exp + 29 list: exp • "," list + 30 | exp • + + "," shift, and go to state 30 + OPERATOR shift, and go to state 16 + + $default reduce using rule 30 (list) + + +State 22 + + 25 exp: "identifier" "(" list • ")" + + ")" shift, and go to state 31 + + +State 23 + + 12 index: ":" • "number" ":" "number" + 16 | ":" • ":" "number" + 17 | ":" • "number" ":" + 18 | ":" • "number" + + ":" shift, and go to state 32 + "number" shift, and go to state 33 + + +State 24 + + 11 index: "number" • ":" "number" ":" "number" + 13 | "number" • ":" ":" "number" + 14 | "number" • ":" "number" ":" + 15 | "number" • ":" "number" + 19 | "number" • ":" ":" + 20 | "number" • ":" + 21 | "number" • + + ":" shift, and go to state 34 + + $default reduce using rule 21 (index) + + +State 25 + + 8 indices_list: indices_list • "," index + 26 exp: "identifier" "[" indices_list • "]" + + "," shift, and go to state 35 + "]" shift, and go to state 36 + + +State 26 + + 9 indices_list: index • + + $default reduce using rule 9 (indices_list) + + +State 27 + + 24 exp: exp • OPERATOR exp + 24 | exp OPERATOR exp • + + OPERATOR shift, and go to state 16 + + OPERATOR [reduce using rule 24 (exp)] + $default reduce using rule 24 (exp) + + +State 28 + + 7 assignment: "identifier" ":=" "identifier" "[" • indices_list "]" + + ":" shift, and go to state 23 + "number" shift, and go to state 24 + + "," reduce using rule 10 (indices_list) + "," [reduce using rule 22 (index)] + "]" reduce using rule 10 (indices_list) + "]" [reduce using rule 22 (index)] + $default reduce using rule 10 (indices_list) + + indices_list go to state 37 + index go to state 26 + + +State 29 + + 6 assignment: "identifier" ":=" VARNAME "[" • indices_list "]" + + ":" shift, and go to state 23 + "number" shift, and go to state 24 + + "," reduce using rule 10 (indices_list) + "," [reduce using rule 22 (index)] + "]" reduce using rule 10 (indices_list) + "]" [reduce using rule 22 (index)] + $default reduce using rule 10 (indices_list) + + indices_list go to state 38 + index go to state 26 + + +State 30 + + 29 list: exp "," • list + + "(" shift, and go to state 7 + "identifier" shift, and go to state 8 + "number" shift, and go to state 9 + + $default reduce using rule 31 (list) + + exp go to state 21 + list go to state 39 + + +State 31 + + 25 exp: "identifier" "(" list ")" • + + $default reduce using rule 25 (exp) + + +State 32 + + 16 index: ":" ":" • "number" + + "number" shift, and go to state 40 + + +State 33 + + 12 index: ":" "number" • ":" "number" + 17 | ":" "number" • ":" + 18 | ":" "number" • + + ":" shift, and go to state 41 + + $default reduce using rule 18 (index) + + +State 34 + + 11 index: "number" ":" • "number" ":" "number" + 13 | "number" ":" • ":" "number" + 14 | "number" ":" • "number" ":" + 15 | "number" ":" • "number" + 19 | "number" ":" • ":" + 20 | "number" ":" • + + ":" shift, and go to state 42 + "number" shift, and go to state 43 + + $default reduce using rule 20 (index) + + +State 35 + + 8 indices_list: indices_list "," • index + + ":" shift, and go to state 23 + "number" shift, and go to state 24 + + $default reduce using rule 22 (index) + + index go to state 44 + + +State 36 + + 26 exp: "identifier" "[" indices_list "]" • + + $default reduce using rule 26 (exp) + + +State 37 + + 7 assignment: "identifier" ":=" "identifier" "[" indices_list • "]" + 8 indices_list: indices_list • "," index + + "," shift, and go to state 35 + "]" shift, and go to state 45 + + +State 38 + + 6 assignment: "identifier" ":=" VARNAME "[" indices_list • "]" + 8 indices_list: indices_list • "," index + + "," shift, and go to state 35 + "]" shift, and go to state 46 + + +State 39 + + 29 list: exp "," list • + + $default reduce using rule 29 (list) + + +State 40 + + 16 index: ":" ":" "number" • + + $default reduce using rule 16 (index) + + +State 41 + + 12 index: ":" "number" ":" • "number" + 17 | ":" "number" ":" • + + "number" shift, and go to state 47 + + $default reduce using rule 17 (index) + + +State 42 + + 13 index: "number" ":" ":" • "number" + 19 | "number" ":" ":" • + + "number" shift, and go to state 48 + + $default reduce using rule 19 (index) + + +State 43 + + 11 index: "number" ":" "number" • ":" "number" + 14 | "number" ":" "number" • ":" + 15 | "number" ":" "number" • + + ":" shift, and go to state 49 + + $default reduce using rule 15 (index) + + +State 44 + + 8 indices_list: indices_list "," index • + + $default reduce using rule 8 (indices_list) + + +State 45 + + 7 assignment: "identifier" ":=" "identifier" "[" indices_list "]" • + + $default reduce using rule 7 (assignment) + + +State 46 + + 6 assignment: "identifier" ":=" VARNAME "[" indices_list "]" • + + $default reduce using rule 6 (assignment) + + +State 47 + + 12 index: ":" "number" ":" "number" • + + $default reduce using rule 12 (index) + + +State 48 + + 13 index: "number" ":" ":" "number" • + + $default reduce using rule 13 (index) + + +State 49 + + 11 index: "number" ":" "number" ":" • "number" + 14 | "number" ":" "number" ":" • + + "number" shift, and go to state 50 + + $default reduce using rule 14 (index) + + +State 50 + + 11 index: "number" ":" "number" ":" "number" • + + $default reduce using rule 11 (index) diff --git a/source/adios2/toolkit/derived/parser/pregen-source/simple-c b/source/adios2/toolkit/derived/parser/pregen-source/simple-c new file mode 100755 index 0000000000000000000000000000000000000000..83b9114d9f5ce5c324b8675ad739b1808c75dd31 GIT binary patch literal 384104 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ⅅdRu!2f^ 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 N7}s_2{crT=e*pNfT~Yu5 literal 0 HcmV?d00001 diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index 002015b843..f748a777ec 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -2,6 +2,7 @@ #include #include +#include #include #include #include @@ -36,13 +37,9 @@ TEST(DerivedCorrectness, AddCorrectnessTest) std::vector varname = {"sim1/Ux", "sim1/Uy", "sim1/Uz"}; std::string derivedname = "derived/addU"; - std::cout << "Define Variable " << varname[0] << std::endl; auto Ux = bpOut.DefineVariable(varname[0], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - std::cout << "Define Variable " << varname[1] << std::endl; auto Uy = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - std::cout << "Define Variable " << varname[2] << std::endl; auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - std::cout << "Define Derived Variable " << derivedname << std::endl; // clang-format off auto addU = bpOut.DefineDerivedVariable(derivedname, "x:" + varname[0] + " \n" @@ -172,6 +169,259 @@ TEST(DerivedCorrectness, MagCorrectnessTest) bpFileReader.Close(); } +/* + * Linear Interpolation - average difference around point "idx" + * + */ +// T linear_interp (T* data, size_t idx, size_t count, size_t stride, size_t margin, bool center) +float linear_interp (std::vector data, size_t idx, size_t count, size_t stride) +{ + size_t ind1 = idx - stride; + size_t ind2 = idx + stride; + bool boundary = false; + if (idx < stride) + { + ind1 = idx; + boundary = true; + } + if (count - idx <= stride) + { + ind2 = idx; + boundary = true; + } + // If stride is out of bounds in both directions, ind1 = ind2 = idx + // return 0 + return (data[ind2] - data[ind1]) / (boundary? 1: 2); +} + +/* + * Input: 3D vector field F(x,y,z)= {F1(x,y,z), F2(x,y,z), F3(x,y,z)} + * + * inputData - (3) components of 3D vector field + * margin - how many elements to each size will be used in approximating partial derivatives + * center - include point (x,y,z) in approximating of partial derivative at that point + * + * Computation: + * curl(F(x,y,z)) = (partial(F3,y) - partial(F2,z))i + * + (partial(F1,z) - partial(F3,x))j + * + (partial(F2,x) - partial(F1,y))k + * + * boundaries are calculated only with data in block + * (ex: partial derivatives in x direction at point (0,0,0) + * only use data from (1,0,0), etc ) + * + * Return: + * (3) components of curl + */ +//std::vector computecurl3D +//const std::vector inputData, size_t xcount, size_t ycount, size_t zcount, size_t margin, bool center, std::function pdcomp) +std::vector> computecurl3D (std::vector inputX, std::vector inputY, std::vector inputZ, size_t xcount, size_t ycount, size_t zcount) +{ + // ToDo - verify how to navigate over the inputData spaces + size_t dataSize = xcount * ycount * zcount; + size_t xstride = ycount * zcount; + size_t ystride = zcount; + size_t zstride = 1; + + std::vector curlx(dataSize); + std::vector curly(dataSize); + std::vector curlz(dataSize); + std::vector> curl = {curlx, curly, curlz}; + // std::vector curl = {(T*)malloc(xcount * ycount * zcount * sizeof(T)), (T*)malloc(xcount * ycount * zcount * sizeof(T)), (T*)malloc(xcount * ycount * zcount * sizeof(T))}; + + for (size_t i = 0; i < xcount; ++i) + { + for (size_t j = 0; j < ycount; ++j) + { + for (size_t k = 0; k < zcount; ++k) + { + size_t idx = (i * xstride) + (j * ystride) + (k * zstride); + curl[0][idx] = linear_interp(inputZ, idx, dataSize, ystride) - linear_interp(inputY, idx, dataSize, zstride); + curl[1][idx] = linear_interp(inputX, idx, dataSize, zstride) - linear_interp(inputZ, idx, dataSize, xstride); + curl[2][idx] = linear_interp(inputY, idx, dataSize, xstride) - linear_interp(inputX, idx, dataSize, ystride); + } + } + } + + return curl; +} + +TEST(DerivedCorrectness, CurlCorrectnessTest) +{ + const size_t Nx = 25, Ny = 70, Nz = 13; + float error_limit = 0.0000001; + + // Application variable + std::vector simArray1(Nx * Ny * Nz); + std::vector simArray2(Nx * Ny * Nz); + std::vector simArray3(Nx * Ny * Nz); + for (float x = 0; x < Nx; ++x) + { + for (float y = 0; y < Ny; ++y) + { + for (float z = 0; z < Nz; ++z) + { + size_t idx = (x * Ny * Nz) + (y * Nz) + z; + // Linear curl example + simArray1[idx] = (6 * x * y) + (7 * z); + simArray2[idx] = (4 * x * z) + pow(y, 2); + simArray3[idx] = sqrt(z) + (2 * x * y); + /* Less linear example + simArray1[idx] = sin(z); + simArray2[idx] = 4 * x; + simArray3[idx] = pow(y, 2) * cos(x); + */ + /* Nonlinear example + simArray1[idx] = exp(2 * y) * sin(x); + simArray2[idx] = sqrt(z + 1) * cos(x); + simArray3[idx] = pow(x, 2) * sin(y) + (6 * z); + */ + } + } + } + + adios2::ADIOS adios; + adios2::IO bpOut = adios.DeclareIO("BPWriteExpression"); + std::vector varname = {"sim3/VX", "sim3/VY", "sim3/VZ"}; + std::string derivedname = "derived/curlV"; + + auto VX = bpOut.DefineVariable(varname[0], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); + auto VY = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); + auto VZ = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); + // clang-format off + auto curlV = bpOut.DefineDerivedVariable(derivedname, + "Vx:" + varname[0] + " \n" + "Vy:" + varname[1] + " \n" + "Vz:" + varname[2] + " \n" + "curl(Vx,Vy,Vz)", + adios2::DerivedVarType::StoreData); + // clang-format on + std::string filename = "expCurl.bp"; + adios2::Engine bpFileWriter = bpOut.Open(filename, adios2::Mode::Write); + + bpFileWriter.BeginStep(); + bpFileWriter.Put(VX, simArray1.data()); + bpFileWriter.Put(VY, simArray2.data()); + bpFileWriter.Put(VZ, simArray3.data()); + bpFileWriter.EndStep(); + bpFileWriter.Close(); + + adios2::IO bpIn = adios.DeclareIO("BPReadCurlExpression"); + adios2::Engine bpFileReader = bpIn.Open(filename, adios2::Mode::Read); + + std::vector readVX; + std::vector readVY; + std::vector readVZ; + // TODO/DEBUG - VERIFY DATATYPE + std::vector readCurl; + + std::vector> calcCurl; + double sum_x = 0; + double sum_y = 0; + double sum_z = 0; + // keep count of how many data points were ignored + // error values will be skipped for data values of infinity + size_t inf_x = 0; + size_t inf_y = 0; + size_t inf_z = 0; + bpFileReader.BeginStep(); + auto varVX = bpIn.InquireVariable(varname[0]); + auto varVY = bpIn.InquireVariable(varname[1]); + auto varVZ = bpIn.InquireVariable(varname[2]); + auto varCurl = bpIn.InquireVariable(derivedname); + + bpFileReader.Get(varVX, readVX); + bpFileReader.Get(varVY, readVY); + bpFileReader.Get(varVZ, readVZ); + bpFileReader.Get(varCurl, readCurl); + bpFileReader.EndStep(); + + float curl_x, curl_y, curl_z; + float err_x, err_y, err_z; + for (float x = 0; x < Nx; ++x) + { + for (float y = 0; y < Ny; ++y) + { + for (float z = 0; z < Nz; ++z) + { + size_t idx = (x * Ny * Nz) + (y * Nz) + z; + // Linear example + curl_x = -(2 * x); + curl_y = 7 - (2 * y); + curl_z = (4 * z) - (6 * x); + /* Less linear + curl_x = 2 * y * cos(x); + curl_y = cos(z) + (pow(y, 2) * sin(x)); + curl_z = 4; + */ + /* Nonlinear example + curl_x = pow(x, 2) * cos(y) - (cos(x) / (2 * sqrt(z + 1))); + curl_y = -2 * x * sin(y); + curl_z = -sqrt(z + 1) * sin(x) - (2 * exp(2 * y) * sin(x)); + */ + if (fabs(curl_x) == std::numeric_limits::infinity()) + { + err_x = 0; + ++inf_x; + } + else if (fabs(curl_x) < 1) + { + err_x = fabs(curl_x - readCurl[3 * idx]) / (1 + fabs(curl_x)); + } + else + { + err_x = fabs(curl_x - readCurl[3 * idx]) / fabs(curl_x); + } + if (fabs(curl_y) == std::numeric_limits::infinity()) + { + err_y = 0; + ++inf_y; + } + else if (fabs(curl_y) < 1) + { + err_y = fabs(curl_y - readCurl[3 * idx + 1]) / (1 + fabs(curl_y)); + } + else + { + err_y = fabs(curl_y - readCurl[3 * idx + 1]) / fabs(curl_y); + } + if (fabs(curl_z) == std::numeric_limits::infinity()) + { + err_z = 0; + ++inf_z; + } + else if (fabs(curl_z) < 1) + { + err_z = fabs(curl_z - readCurl[3 * idx + 2]) / (1 + fabs(curl_z)); + } + else + { + err_z = fabs(curl_z - readCurl[3 * idx + 2]) / fabs(curl_z); + } + sum_x += err_x; + sum_y += err_y; + sum_z += err_z; + std::cout << "Test curl at (" << x << ", " << y << ", " << z << ")\n"; + std::cout << "\tExpected: <" << curl_x << ", " << curl_y << ", " << curl_z << ">\n"; + std::cout << "\t Read: <" << readCurl[3 * idx] << ", " << readCurl[3 * idx + 1] << ", " << readCurl[3 * idx + 2] << ">" << std::endl; + std::cout << "\tRelative error: " << err_x << ", " << err_y << ", " << err_z << std::endl; + } + } + } + bpFileReader.Close(); + std::cout << "Finished reading curl. Ave rel error: " << (sum_x + sum_y + sum_z)/ ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)) << std::endl; + std::cout << "\tave in x: " << (sum_x / ((Nx * Ny * Nz) - inf_x)) << std::endl; + std::cout << "\tskipped x values (infinity): " << inf_x << std::endl; + std::cout << "\tave in y: " << (sum_y / ((Nx * Ny * Nz) - inf_y)) << std::endl; + std::cout << "\tskipped y values (infinity): " << inf_y << std::endl; + std::cout << "\tave in z: " << (sum_z / ((Nx * Ny * Nz) - inf_z)) << std::endl; + std::cout << "\tskipped z values (infinity): " << inf_z << std::endl; + EXPECT_LT((sum_x + sum_y + sum_z) / ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)), error_limit); + EXPECT_LT(sum_x / ((Nx * Ny * Nz) - inf_x), error_limit); + EXPECT_LT(sum_y / ((Nx * Ny * Nz) - inf_y), error_limit); + EXPECT_LT(sum_z / ((Nx * Ny * Nz) - inf_z), error_limit); +} + int main(int argc, char **argv) { int result; From 98997ca680f18c822a9b5dd49f7974d46f27945d Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Tue, 20 Feb 2024 17:04:28 -0500 Subject: [PATCH 06/46] CMake Tweaks --- source/adios2/CMakeLists.txt | 28 ++++++++++++++++++-- source/adios2/toolkit/derived/Expression.cpp | 2 +- 2 files changed, 27 insertions(+), 3 deletions(-) diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index 6a420f00a6..3f1f5aed11 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -135,11 +135,35 @@ if (ADIOS2_HAVE_Derived_Variable) toolkit/derived/Expression.cpp toolkit/derived/Function.cpp toolkit/derived/Function.tcc toolkit/derived/ExprHelper.h) + set_target_properties(adios2_core PROPERTIES + INCLUDE_DIRECTORIES "$;$") + find_package(BISON "3.8.2") + find_package(FLEX) + + if(NOT BISON_FOUND OR NOT FLEX_FOUND) + include(ADIOSBisonFlexSub) + SETUP_ADIOS_BISON_FLEX_SUB() + else() + BISON_TARGET(MyParser + toolkit/derived/parser/parser.y + ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp + DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/parser.h) + FLEX_TARGET(MyScanner + toolkit/derived/parser/lexer.l + ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp + DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/lexer.h) + ADD_FLEX_BISON_DEPENDENCY(MyScanner MyParser) + endif() add_library(adios2_core_derived - toolkit/derived/parser/pregen-source/lexer.cpp - toolkit/derived/parser/pregen-source/parser.cpp + ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp + ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp toolkit/derived/parser/ASTDriver.cpp toolkit/derived/parser/ASTNode.cpp) + set_target_properties(adios2_core_derived PROPERTIES + VISIBILITY_INLINES_HIDDEN ON + INCLUDE_DIRECTORIES "$;$" + EXPORT_NAME core_derived + OUTPUT_NAME adios2${ADIOS2_LIBRARY_SUFFIX}_core_derived) target_link_libraries(adios2_core PRIVATE adios2_core_derived) set(maybe_adios2_core_derived adios2_core_derived) endif() diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index d773236526..3fd805bd8e 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -3,7 +3,7 @@ #include "Expression.h" #include "parser/ASTNode.h" -#include "parser/parser.h" +#include "parser.h" namespace adios2 { From 69f54f1109aa192d499fa8464735433b96d8cd1e Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Wed, 21 Feb 2024 06:55:11 -0500 Subject: [PATCH 07/46] whoops, missed the cmake file. --- cmake/ADIOSBisonFlexSub.cmake | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 cmake/ADIOSBisonFlexSub.cmake diff --git a/cmake/ADIOSBisonFlexSub.cmake b/cmake/ADIOSBisonFlexSub.cmake new file mode 100644 index 0000000000..a9fa46274d --- /dev/null +++ b/cmake/ADIOSBisonFlexSub.cmake @@ -0,0 +1,29 @@ +FUNCTION (SETUP_ADIOS_BISON_FLEX_SUB) + +IF ((${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") OR + (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")) + set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source") +elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Windows") + set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source/Windows") +else() + if (NOT BISON_FOUND) + message (FATAL_ERROR "Bison was not found and no pregenerated Bison/Flex" + "source is available for ${CMAKE_SYSTEM_NAME}. Please install Bison or Yacc") + + else() + message (FATAL_ERROR "Flex was not found and no pregenerated Bison/Flex" + "source is available for ${CMAKE_SYSTEM_NAME}. Please install Bison or Yacc") + endif() +ENDIF() + +ADD_CUSTOM_COMMAND(OUTPUT parser.cpp + COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/parser.cpp ${CMAKE_CURRENT_BINARY_DIR} + COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/parser.h ${CMAKE_CURRENT_BINARY_DIR} + COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/location.hh ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Using pre-generated Bison Output from ${BISON_FLEX_PRECOMPILE_DIR}") +ADD_CUSTOM_COMMAND(OUTPUT lexer.c + COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/lexer.cpp ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Using pre-generated Flex Output from ${BISON_FLEX_PRECOMPILE_DIR}") + +set (BISON_Parser_OUTPUT_SOURCE parser.cpp PARENT_SCOPE) +ENDFUNCTION() From 3c25ccb0194df7003e128a6c9b9e267cbbc2ab71 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Thu, 22 Feb 2024 10:47:11 -0500 Subject: [PATCH 08/46] Updated parser merged with adios, updated error message for missing operation, missing curl implementation --- cmake/ADIOSBisonFlexSub.cmake | 2 +- source/adios2/toolkit/derived/ExprHelper.h | 2 +- source/adios2/toolkit/derived/Expression.cpp | 37 ++++++--- .../toolkit/derived/parser/ASTDriver.cpp | 8 ++ .../adios2/toolkit/derived/parser/ASTDriver.h | 12 ++- .../adios2/toolkit/derived/parser/ASTNode.cpp | 33 +++----- .../adios2/toolkit/derived/parser/ASTNode.h | 10 +++ .../adios2/toolkit/derived/parser/driver.cpp | 4 +- source/adios2/toolkit/derived/parser/lexer.l | 8 +- source/adios2/toolkit/derived/parser/parser.y | 8 +- .../derived/parser/pregen-source/lexer.cpp | 8 +- .../derived/parser/pregen-source/parser.cpp | 74 +++++++++--------- .../derived/parser/pregen-source/parser.h | 14 +++- .../derived/parser/pregen-source/simple-c | Bin 384104 -> 469376 bytes .../derived/TestBPDerivedCorrectness.cpp | 18 ++--- 15 files changed, 141 insertions(+), 97 deletions(-) diff --git a/cmake/ADIOSBisonFlexSub.cmake b/cmake/ADIOSBisonFlexSub.cmake index a9fa46274d..0d89e8b823 100644 --- a/cmake/ADIOSBisonFlexSub.cmake +++ b/cmake/ADIOSBisonFlexSub.cmake @@ -21,7 +21,7 @@ ADD_CUSTOM_COMMAND(OUTPUT parser.cpp COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/parser.h ${CMAKE_CURRENT_BINARY_DIR} COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/location.hh ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Using pre-generated Bison Output from ${BISON_FLEX_PRECOMPILE_DIR}") -ADD_CUSTOM_COMMAND(OUTPUT lexer.c +ADD_CUSTOM_COMMAND(OUTPUT lexer.cpp COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/lexer.cpp ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Using pre-generated Flex Output from ${BISON_FLEX_PRECOMPILE_DIR}") diff --git a/source/adios2/toolkit/derived/ExprHelper.h b/source/adios2/toolkit/derived/ExprHelper.h index c72888f95f..e1d31b8bff 100644 --- a/source/adios2/toolkit/derived/ExprHelper.h +++ b/source/adios2/toolkit/derived/ExprHelper.h @@ -57,4 +57,4 @@ inline ExpressionOperator get_op(std::string op) { return string_to_op.at(op); } } } -#endif \ No newline at end of file +#endif diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index 3fd805bd8e..d25525af50 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -2,19 +2,31 @@ #define ADIOS2_DERIVED_Expression_CPP_ #include "Expression.h" -#include "parser/ASTNode.h" -#include "parser.h" +#include "parser/ASTDriver.h" namespace adios2 { namespace detail { -adios2::derived::ExpressionTree ASTNode_to_ExpressionTree(adios2::detail::ASTNode *node) +// helper function +adios2::detail::ExpressionOperator convert_op(std::string opname) { - adios2::derived::ExpressionTree exprTree_node(node->operation); - for (adios2::detail::ASTNode *e : node->sub_expr) + try + { + return adios2::detail::get_op(opname); + } + catch (std::out_of_range& e) { - switch (e->operation) + helper::Throw("Derived", "ExprHelper", "get_op", "Parser cannot recognize operator '" + opname + "'."); + } +}; + +adios2::derived::ExpressionTree ASTNode_to_ExpressionTree(adios2::detail::ASTNode *node) +{ + adios2::derived::ExpressionTree exprTree_node(convert_op(node->get_opname())); + for (adios2::detail::ASTNode *e : node->get_subexprs()) + { + switch (convert_op(e->get_opname())) { case adios2::detail::ExpressionOperator::OP_ALIAS: // add variable given by alias // add an index operation in the chain if the variable contains indeces @@ -25,19 +37,19 @@ adios2::derived::ExpressionTree ASTNode_to_ExpressionTree(adios2::detail::ASTNod index_expr.add_child(e->lookup_var_path(e->alias)); expTree_node->add_child(expr); }*/ - exprTree_node.add_child(e->lookup_var_path(e->alias)); + exprTree_node.add_child(e->get_varname()); break; case adios2::detail::ExpressionOperator::OP_PATH: // add variable name - exprTree_node.add_child(e->alias); + exprTree_node.add_child(e->get_varname()); break; case adios2::detail::ExpressionOperator::OP_NUM: // set the base value for the operation - exprTree_node.set_base(e->value); + exprTree_node.set_base(e->get_value()); break; default: // if the children nodes are other expressions, convert them to expressions auto temp_node = ASTNode_to_ExpressionTree(e); // move from a binary to a multinary tree if the child has the same operation - if (e->operation == node->operation && - adios2::detail::op_property.at(e->operation).is_associative) + if (convert_op(e->get_opname()) == convert_op(node->get_opname()) && + adios2::detail::op_property.at(convert_op(e->get_opname())).is_associative) { // concatenate exprTree with temp_node for (std::tuple childTree : @@ -65,7 +77,8 @@ namespace derived Expression::Expression(std::string string_exp) : ExprString(string_exp), m_Shape({0}), m_Start({0}), m_Count({0}) { - adios2::detail::ASTNode *root_node = adios2::detail::parse_expression(string_exp); + adios2::detail::ASTDriver drv; + adios2::detail::ASTNode *root_node = drv.parse(string_exp); m_Expr = adios2::detail::ASTNode_to_ExpressionTree(root_node); } diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.cpp b/source/adios2/toolkit/derived/parser/ASTDriver.cpp index ee91a3a6b0..5bde639271 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.cpp +++ b/source/adios2/toolkit/derived/parser/ASTDriver.cpp @@ -1,5 +1,10 @@ #include "ASTDriver.h" +namespace adios2 +{ +namespace detail +{ + using indx_type = std::vector>; ASTDriver::ASTDriver() @@ -83,3 +88,6 @@ void ASTDriver::createNode(std::string alias, indx_type indices) node->pushback_subexpr(new ASTNode("ALIAS", alias)); holding.push(node); } + +} +} diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.h b/source/adios2/toolkit/derived/parser/ASTDriver.h index 3f1ff646c3..025a30e44f 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.h +++ b/source/adios2/toolkit/derived/parser/ASTDriver.h @@ -9,9 +9,14 @@ #include "ASTNode.h" # define YY_DECL \ - adios2::detail::parser::symbol_type yylex (ASTDriver& drv) + adios2::detail::parser::symbol_type yylex (adios2::detail::ASTDriver& drv) YY_DECL; +namespace adios2 +{ +namespace detail +{ + using indx_type = std::vector>; class ASTDriver @@ -20,7 +25,7 @@ class ASTDriver ASTDriver (); // Defined in lexer.l - ASTNode *parse (const char* input); + ASTNode *parse (const std::string input); ASTNode* getAST (); @@ -57,4 +62,7 @@ class ASTDriver // map alias names to variable names and indices from alias definition std::map> aliases; }; + +} +} #endif // ! ASTDRIVER_HH_ diff --git a/source/adios2/toolkit/derived/parser/ASTNode.cpp b/source/adios2/toolkit/derived/parser/ASTNode.cpp index cf2e84b459..1f7fb90313 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.cpp +++ b/source/adios2/toolkit/derived/parser/ASTNode.cpp @@ -1,24 +1,10 @@ -/* ASTNode for calc++. -*- C++ -*- - - Copyright (C) 2005-2015, 2018-2021 Free Software Foundation, Inc. - - This file is part of Bison, the GNU Compiler Compiler. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - #include "ASTNode.h" +namespace adios2 +{ +namespace detail +{ + ASTNode::ASTNode () { } @@ -105,7 +91,6 @@ std::string ASTNode::get_opname() return opname; } - std::string ASTNode::get_alias() { return alias; @@ -121,6 +106,11 @@ std::vector> ASTNode::get_indices() return indices; } +double ASTNode::get_value() +{ + return value; +} + void ASTNode::set_varname(const std::string s) { varname = s; @@ -130,3 +120,6 @@ void ASTNode::set_indices(const std::vector> idx) { indices = idx; } + +} +} diff --git a/source/adios2/toolkit/derived/parser/ASTNode.h b/source/adios2/toolkit/derived/parser/ASTNode.h index 6650a26694..c5ac856657 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.h +++ b/source/adios2/toolkit/derived/parser/ASTNode.h @@ -4,6 +4,11 @@ #include #include +namespace adios2 +{ +namespace detail +{ + class ASTNode { public: @@ -23,6 +28,7 @@ class ASTNode std::string get_alias(); std::string get_varname(); std::vector> get_indices(); + double get_value(); void set_varname(const std::string); void set_indices(const std::vector>); @@ -32,6 +38,10 @@ class ASTNode std::string alias; std::string varname; std::vector> indices; + double value; }; + +} +} #endif // ! ASTNODE_HH diff --git a/source/adios2/toolkit/derived/parser/driver.cpp b/source/adios2/toolkit/derived/parser/driver.cpp index a9bfe91e7b..4f69654a31 100644 --- a/source/adios2/toolkit/derived/parser/driver.cpp +++ b/source/adios2/toolkit/derived/parser/driver.cpp @@ -5,12 +5,12 @@ int main (int argc, char *argv[]) { - ASTDriver drv; + adios2::detail::ASTDriver drv; // char* str_expr = "one := 1\ntwo := 2\nthree := 3\n(one + two * three) * two * three"; char* str_expr = "var x:= sim1/points/x\nvar y := sim1/points/y\nvar z:=sim_1/points-more/x[ , , ::5]\nvar a:=sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; std::cout << "Parse input: " << str_expr << std::endl; - ASTNode *result = drv.parse(str_expr); + adios2::detail::ASTNode *result = drv.parse(str_expr); std::cout << "Result: " << std::endl; std::cout << result->printpretty(""); diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index be321d9dc8..a6b16180bf 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -119,7 +119,7 @@ blank [ \t\r] %} %% %{ - // A handy shortcut to the location held by the ASTDriver. + // A handy shortcut to the location held by the adios2::detail::ASTDriver. adios2::detail::location& loc = drv.location; // Code run each time yylex is called. loc.step (); @@ -157,11 +157,11 @@ make_INT (const std::string &s, const adios2::detail::parser::location_type& loc return adios2::detail::parser::make_INT ((int) n, loc); } -ASTNode* -ASTDriver::parse (const char* input) +adios2::detail::ASTNode* +adios2::detail::ASTDriver::parse (const std::string input) { adios2::detail::parser parse (*this); - yy_scan_string(input); + yy_scan_string(input.c_str()); parse.set_debug_level (trace_parsing); parse (); std::cout << "Parsed input: " << input << std::endl; diff --git a/source/adios2/toolkit/derived/parser/parser.y b/source/adios2/toolkit/derived/parser/parser.y index f72cb11a36..8f184aabfe 100644 --- a/source/adios2/toolkit/derived/parser/parser.y +++ b/source/adios2/toolkit/derived/parser/parser.y @@ -12,7 +12,13 @@ #include #include #include - class ASTDriver; + namespace adios2 + { + namespace detail + { + class ASTDriver; + } + } } // The parsing context. diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index 6e6f5b3021..d0601fa284 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -933,7 +933,7 @@ YY_DECL #line 123 "..//lexer.l" - // A handy shortcut to the location held by the ASTDriver. + // A handy shortcut to the location held by the adios2::detail::ASTDriver. adios2::detail::location& loc = drv.location; // Code run each time yylex is called. loc.step (); @@ -2220,11 +2220,11 @@ make_INT (const std::string &s, const adios2::detail::parser::location_type& loc return adios2::detail::parser::make_INT ((int) n, loc); } -ASTNode* -ASTDriver::parse (const char* input) +adios2::detail::ASTNode* +adios2::detail::ASTDriver::parse (const std::string input) { adios2::detail::parser parse (*this); - yy_scan_string(input); + yy_scan_string(input.c_str()); parse.set_debug_level (trace_parsing); parse (); std::cout << "Parsed input: " << input << std::endl; diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp index 1ea0a8687a..0f610ee6a0 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp @@ -42,7 +42,7 @@ // Unqualified %code blocks. -#line 27 "..//parser.y" +#line 33 "..//parser.y" #include "ASTDriver.h" #include "ASTNode.h" @@ -643,187 +643,187 @@ namespace adios2 { namespace detail { switch (yyn) { case 2: // unit: assignments exp -#line 65 "..//parser.y" +#line 71 "..//parser.y" { /*drv.root = $2;*//*drv.result = $2;*/ } #line 649 "parser.cpp" break; case 3: // assignments: %empty -#line 68 "..//parser.y" +#line 74 "..//parser.y" {} #line 655 "parser.cpp" break; case 4: // assignments: "var" assignment "\n" assignments -#line 69 "..//parser.y" +#line 75 "..//parser.y" {} #line 661 "parser.cpp" break; case 5: // assignment: "identifier" ":=" VARNAME -#line 72 "..//parser.y" +#line 78 "..//parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 667 "parser.cpp" break; case 6: // assignment: "identifier" ":=" "identifier" -#line 73 "..//parser.y" +#line 79 "..//parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 673 "parser.cpp" break; case 7: // assignment: "identifier" ":=" VARNAME "[" indices_list "]" -#line 74 "..//parser.y" +#line 80 "..//parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 679 "parser.cpp" break; case 8: // assignment: "identifier" ":=" "identifier" "[" indices_list "]" -#line 75 "..//parser.y" +#line 81 "..//parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 685 "parser.cpp" break; case 9: // indices_list: indices_list "," index -#line 78 "..//parser.y" +#line 84 "..//parser.y" { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } #line 691 "parser.cpp" break; case 10: // indices_list: index -#line 79 "..//parser.y" +#line 85 "..//parser.y" { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } #line 697 "parser.cpp" break; case 11: // indices_list: %empty -#line 80 "..//parser.y" +#line 86 "..//parser.y" { yylhs.value.as < std::vector> > () = {}; } #line 703 "parser.cpp" break; case 12: // index: "number" ":" "number" ":" "number" -#line 83 "..//parser.y" +#line 89 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 709 "parser.cpp" break; case 13: // index: ":" "number" ":" "number" -#line 84 "..//parser.y" +#line 90 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 715 "parser.cpp" break; case 14: // index: "number" ":" ":" "number" -#line 85 "..//parser.y" +#line 91 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } #line 721 "parser.cpp" break; case 15: // index: "number" ":" "number" ":" -#line 86 "..//parser.y" +#line 92 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } #line 727 "parser.cpp" break; case 16: // index: "number" ":" "number" -#line 87 "..//parser.y" +#line 93 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 733 "parser.cpp" break; case 17: // index: ":" ":" "number" -#line 88 "..//parser.y" +#line 94 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } #line 739 "parser.cpp" break; case 18: // index: ":" "number" ":" -#line 89 "..//parser.y" +#line 95 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } #line 745 "parser.cpp" break; case 19: // index: ":" "number" -#line 90 "..//parser.y" +#line 96 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } #line 751 "parser.cpp" break; case 20: // index: "number" ":" ":" -#line 91 "..//parser.y" +#line 97 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } #line 757 "parser.cpp" break; case 21: // index: "number" ":" -#line 92 "..//parser.y" +#line 98 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } #line 763 "parser.cpp" break; case 22: // index: "number" -#line 93 "..//parser.y" +#line 99 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 769 "parser.cpp" break; case 23: // index: %empty -#line 94 "..//parser.y" +#line 100 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } #line 775 "parser.cpp" break; case 24: // exp: "number" -#line 98 "..//parser.y" +#line 104 "..//parser.y" { yylhs.value.as < int > () = yystack_[0].value.as < int > (); } #line 781 "parser.cpp" break; case 25: // exp: exp OPERATOR exp -#line 99 "..//parser.y" +#line 105 "..//parser.y" { drv.createNode(yystack_[1].value.as < std::string > (), 2); } #line 787 "parser.cpp" break; case 26: // exp: "identifier" "(" list ")" -#line 100 "..//parser.y" +#line 106 "..//parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } #line 793 "parser.cpp" break; case 27: // exp: "identifier" "[" indices_list "]" -#line 101 "..//parser.y" +#line 107 "..//parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 799 "parser.cpp" break; case 28: // exp: "identifier" -#line 102 "..//parser.y" +#line 108 "..//parser.y" { drv.createNode(yystack_[0].value.as < std::string > ()); } #line 805 "parser.cpp" break; case 29: // exp: "(" exp ")" -#line 103 "..//parser.y" +#line 109 "..//parser.y" { } #line 811 "parser.cpp" break; case 30: // list: exp "," list -#line 107 "..//parser.y" +#line 113 "..//parser.y" { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } #line 817 "parser.cpp" break; case 31: // list: exp -#line 108 "..//parser.y" +#line 114 "..//parser.y" { yylhs.value.as < int > () = 1; } #line 823 "parser.cpp" break; case 32: // list: %empty -#line 109 "..//parser.y" +#line 115 "..//parser.y" { yylhs.value.as < int > () = 0; } #line 829 "parser.cpp" break; @@ -1379,10 +1379,10 @@ namespace adios2 { namespace detail { const signed char parser::yyrline_[] = { - 0, 65, 65, 68, 69, 72, 73, 74, 75, 78, - 79, 80, 83, 84, 85, 86, 87, 88, 89, 90, - 91, 92, 93, 94, 98, 99, 100, 101, 102, 103, - 107, 108, 109 + 0, 71, 71, 74, 75, 78, 79, 80, 81, 84, + 85, 86, 89, 90, 91, 92, 93, 94, 95, 96, + 97, 98, 99, 100, 104, 105, 106, 107, 108, 109, + 113, 114, 115 }; void @@ -1417,7 +1417,7 @@ namespace adios2 { namespace detail { } } // adios2::detail #line 1419 "parser.cpp" -#line 110 "..//parser.y" +#line 116 "..//parser.y" void diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/parser.h index 340f7ba54c..99e5a24294 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.h @@ -50,9 +50,15 @@ #include #include #include - class ASTDriver; + namespace adios2 + { + namespace detail + { + class ASTDriver; + } + } -#line 56 "parser.h" +#line 62 "parser.h" # include # include // std::abort @@ -193,7 +199,7 @@ #line 6 "..//parser.y" namespace adios2 { namespace detail { -#line 197 "parser.h" +#line 203 "parser.h" @@ -1635,7 +1641,7 @@ switch (yykind) #line 6 "..//parser.y" } } // adios2::detail -#line 1639 "parser.h" +#line 1645 "parser.h" diff --git a/source/adios2/toolkit/derived/parser/pregen-source/simple-c b/source/adios2/toolkit/derived/parser/pregen-source/simple-c index 83b9114d9f5ce5c324b8675ad739b1808c75dd31..60cbdc32f99ad4011a85c76ece9b40190fa356a2 100755 GIT binary patch literal 469376 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

5;^aF9SoVNef zBhfx#)@Hf={RXg)rO=MPen+^KjtRm~7E03295|iiwdL+Jg)bha0n#LX();oJ-m(Xy zupR;wa-fZ-Vw{JOFZKy^DDFU6qa#hr4|gQ>kBs(1^P>@b zsKAf{Phq)?Wo_GM8Ncj(9KYiT7?oRBoosj+mL0zgyxZpw<8mcmlnA4;hew~oA!^!J zALA%qnf&fn)-#ve-3&G%7t`NsWz&Ssd3%UTjaXIHp3N#oQ4iaNE8z-B2uE!_bURMrwYO-C&h!VVh)4o`QxuU&^1~53BYO@90{;Z!!AS)4z+O`n>rlkK-ZxN82JA zSx^EHa-6Gd_Zc{|%5m!53c%uXIab6-=@9h;H%bmqlL<$YiOKZ=J<9patxADAIjxB3 zaSPr6>0*n>%8%YyLyyQ`C8$s{sxF4432PT*3%QdIx+@HF+O^Jo5nYxg5Eft(a*YWu z25_vsqlM*k3Wnv4n!q#d^>j26tz;KMWQLC^v>cP)bzi$w=E!{!rzD)@0HVAI0qU^Y z=##to!7ltb9PrUj9_;g6ERy(@yu-GYIH$Kc-5AdT8=j_CZe97%AIhyDgG) zLnXHN^sSWmuyRu$_$jUb+LXSuEsLIwLMoeek&TZO;>j zYV_Td7j3s5|Hbevqco)Y_xfFJ3x%PJNYJ0?L_j3*Iq{_f6p;EazCMvx&pt4p0){Y& z%A0*%Lp&z!8}X;`K?8o_O)CFY`6d_XXsqo^5Rut$(S(X;{tDYv3{i6ywmvn@eSPo7 zDuS#-i*@}`;+^N??;PRC>(>~6Guw~5IFk2JU;I7$=kFy>er`|Y2;{qsX?`fuGo zUoc#?hu?3QJ%pYN_RoLsCrUMNk=h_K1fCo1pO5ejdd!iF8`DGcudK|{4(4SD54D`Xgy7-RZvHKNL?RohOSh~`Y+Ny4em?x_|Y*!$~ZG1 zcVf8ETB->xg)={@*Sh{oXe@Dl-dg3eGFqFE=f^K4xz3hSkwY_9ioayR{lZZe?gaZx z^uluEaXFDupJk`;Lj!gR@9QMg?k2E)7U{R!CrMyP>ZBkbIneKR?^ecZ0K3&-CFJ zBhug*o_hx5BrOD#y0*L4p!hlxJ6~K%?}=9=x{v+c$MSZ7k+f?~H$uCPik}1**jX3Y z7ZEnjK#E$T#+}g(J;VS)x!MhZ&*?If-GarX9zZ*e)CKyu!OH0(5>Csr{37#Yr_>;d zi&-PT_C&47p|t6f4rPu$^24eeW98^$0*@{FxWUTl3J&_P{37$@D>~J3G|9EIcz*3% z{uJFYd25*{2u?Ktn^UCJ%1xxCGS@1Q*xC2Up9HGm{Hdw{MJT=@Sz+Mi81>Y~XW(>>XyL+6Chbhuv+08 z8z#fZ?N4xo{2Zku_i3Y}%EEc3YmgP{t=K&%>$E1Qy>e3@hDeo=o)30lpejt@ed<4S zYhBAidY@eLO)9vK8v9As7T^fKn96b5z-=EdROb~L$#~6D-yaH>DZH-V5`L+7!KL6# ze5j5_@Z5#(?G+AaUkH%*qz0*qQ5(R~TXWKCn`z)$b!>TRYdT&gPXGh8_Nx={5cmq< z0lFcI&`>@GU|(Az8M?-QzkbmIxO)`U_N%1|xylbxIbaxjg~D zgC}kOo&Sll@qEDBuX^?!7@hWe_P@FP@Qxa#E>Blq+~&>@pA*6t`ZK1p0To4nd;y>T zkWW#iBggynI*mmva5SBWcfQB>L4 z^Nu7vjR#w}cHz@Ktw66ksQjOXhC3jF0Fzn-8l2t-ZDi;WwR2zJI17GEYUD5?4G5(ZA5RXY%?5}`zy}j*-;N$iI=bufW#fs?Cj)mRf&EsUG zZ`5y1JzyUXjN3E+(MY_?Hd8AX`1|WY{r(cxWXV&YvOP~sj_W)Hyn;YKoOZ;|6&24jtH4>kU0yTb4L^RcdD0iXBnD{=j^rmLU!2eAvn>6uU-NuR2dN1P{!ehN+I)>q~1 z%GRy$+Vd@AncpFU!Y^{EEAn%^RpksV@^cocL`8TW9a|yWROM7HGQlEuX^~>@??6n> z!0r+R;t3Rpn20|Eb|;`odGqli(sz+nZA<#65&aPs+;Q6P@wq=>zo-r4f90KoJX1_U z`L2B@t-S4|&hYU#uyGxKJ%UfZzZp8ME`Lth{Dol!6$Z5L{OgNZ$9YMiZn88{ebbC} zJ>BM9SHEf7k-qBRyg24JPOuQjgAu+StkNW}xL>vJhCO+}8!K3hDLY+FoK zM)&h;u=EdXMUj)D33&_a+wzoKSB%!N4zQ-n^89_VW)=Iw}|68|4kkziXcAN1euS;p!Q`V*y~%qDy62YYhx}@OO^E=V}&IZgdnL=BKC3 z^@C$$zr0Tew49bLaVQ>EqM5}HA2R!JcfZ$1;3wcZeh>L~FO$a<|5E-zZ|FLIf4EJq zEB<_~n)zbLpI-maJwQ8hCqhlpjzPCrUzO%_04!L``$AQ@+odR~lzY5Ai1m@_6ZH$> zPvE|l*e6hv>J0wR?@P=-g8O&}G7kbp5FiLlvHL;!!|Yh8(I&eFF3|?O{b*BupuD^J zatdG5=cnb__&teVd?kYMfMxMH(w)=?>gXxUl-&7&=DyQ?1;|=JaBR2Jhj@rk?Dk-c z$W!k&e!yTwcKZM}L%z#u;%pzQIRZx0Rcv|t`$-OltIF~VX6nK|A|y(!pgj@+h2^cnE@OM^$RG3wR<|*qnZ1$!SH^3>ygSXPrB2la7Glawy`>8mB!d* z>rjhO-yReX{R+ZPGSHJ+4)+`%ef-(DBcX0U49)43QN2p}<=m0*wG}O_*UjDs(r+;uWiQ2%QAp9sB z=|30353GcrEYVT>z&c+=WE%L1;EZTyU zr?UOGxchrlxzylCVKC7}Um(4lqm|+0;&43UnOc3JqVCGSDK3v5De1mE`ODh({t7?i z+Nv`+{U%F9^_Kbwz-W^GwfF(IQN=)Cs4OP!tJ?d}Utrm>5)iainX9IKpXcY-+BWH1 zYR&dnNS7o$UjIh)b>qJmGgxn@2uZlwFNKTE*0QcrAXZepyHHLnloQ4Q)5wFc_-@{g(ruAT#>$m$ULy)ospKuoVUJ zulqv=8_rkGW}$GtGGGbud}R+ysG@TU76GTFSf1n`gOASXwN`!tU039r_JXK07>V;0 z*I&9djM~$8n)6!e6!-U*an_$d_KLb40F@zFP4a1K2r4{=x#5DT4%f-5do2MB3wj?8 z;v+u|MyIl1nxEPte%ASWlAn3seMBFFhOQURZ{^TqdAqfsgXLjAiPMH>oc?KRf?GRaoGEQGbGcs3*Zf+u@%t z!U|b!{{cO=)XOJ5{*my-?VAq3{LF9rSA zsek69Gq3MyVso3ST=jq1dlxu6rz>uFMsj2#8E0J5j!PK?AzI@y8e-Z}IUJX%sS2rE zqj5>4B}E9DHgR%fPL3l{LQo7XhPuRMVnioSh&kihQCj0xM^XD!${-kRnD75zYwzcI z&SjDb`h9)B-t&)Q$E>s{?vuztJjJ}&R8u6pk{uJsIjZ#MlBi<>cj zXURCW)47(cIZdRCNxCzh6B*$9)aQs~oGn!GTVM637Ft_&tv;GiC5_#t9K#(54Mr}w z-x%c?us#aqH(u>jo<8K2m+g*gv(iWQm|M|#IJY$5x_6sa)WJAY!{x8@KyrH+Mv!A7Zvu%w|_~^LFianP(Ma+O%)Z z!DwE8UQ=YB+#J)(&k7%C05goi-bbtBdHJnv^YpP~`6w~=e5i-<5fh#}U(`Zc7fOwe zc@q{?cO|2sy(WR0$^l5b1RZ~)tEWqnu3&}aFni77#%v2^Jr7R~q$b|07$#zri3`{q&X?*rqn9>o2{%6pB z6zc2E)uQnQ`kF8QQu~iD2Pd9+De^BHr2f=)L-in@MyPy4mG0Cv=4Li!?mgk=mt-wu z(_=1^IN7#fC~#<257w2k^1W46*MNQT`%3~ML*PC}TmRBPgm=^``_u$z$!LI2RDZMz zDpGR%Q)~NUw28(nHYTA>&^v<{%r9yljIw)!>9G`qY;h5l$9$wju(frX`caTBU7d3f znR|%(QPO|)j_u{r>qR<5w4!(Iw@T%Wyuwa_KVt21l>1?0D^MnG zh#g?QNAj~L0>iYj_?|0gT?8XF?AqrC-tS7@t$zc_`r~ttKDP(aJ;pDV1|N}LTLJm~ zlXsuy#&WQ)41j1p?!LBl+^6{~OqE6LeVTVY`MGzkm}Z-b=>a6Sox^E@)S@OlOuG*? znEN!hR{}N6+URHP82CQTV|=K=+^3n@NlG9`Tvt8em%v~LQfHh;QCR}sC593R)W<&5 zVD8hLrUZCLgh~2Y*K(icA|Gln_i1jd1X@X8S3m1o?$g}chZ@X%n)mG}BAQJCk3a5< zs9Qv|7}4br(eLquhy?06A8Ii7X&$WvCXv8YKWj&q5SWf=)u?=GBC>l1ph=s%egfrM72iSQPN58WwFoLBrB$ zexPA##}N&SIoMai^+(F1E`}*oT%NFb$LIa##Z3@ShGs_iz<(TRh07NIzxQd1DRTCC zAuHI`_F}DVd1!4nv$oqhrM3k$8D|tEiA|z}3trV`?}NRC;I_)I(Xdqcr5cthzevMU z<>zWxs{C{fOO>CfVX5*XH7r$r5W-)wTINHR~8MbbBDH z@v~+bbXRfm_Dt;O1i89xH7jGx4S}ozuT*=2StJ83`=bc4P+H~&B_||sItf7 zlq9G=p;;MYeiX|NAA;X_wo$-KFyELqm1-E&Bu$gHDPGRK; zkWPlCe3uWuQ;_ZV|E2phGmi+Xy)0GozjvSJWF<36$u#k?w)-^S9|}vB-H4Vfe>_-p zpXQuZHL@GLLvZp6jkpl8z0=_AmRorc*q{((9MeV7CsW2cbOe|tDFvlI3((d z@_6wp5Fj{62v8(DzjB`BiezQJFblYzWat>gB_gY=amQx=rDfP@kqYg#LwVW!p%u-M zOms@)Dnx7#|L@e;{!x4Z16PWcB_pd6q5UkvXd<*1f{H}J?*n-F;i1v+(#8xXQ>S1N zAhfNG8y{H}o+~Sj3Y)R<;3GC`)t2E)xY;PYG?Ecca!6H9axEP2YMvjK!2g<$2g2Yy z3YVI*z_~>@zAf`6L& z{IcfIcpL5%!9$p#?GO{I{|+~vhUfA=w%DxaQI&FmSTb}iCi3`Uk5t{iw=6GPQf5Y1 zKwwWRSXDTs3$LMbEZCIB=OM65QJ`q};mxDap#4ZNRrhDj{f}YD%_$}jsS3wOBZR{3 zV{<1*ja2Bz6}p|!$0+nB9!nJ-OOGnpWdxG}douLSe!?$sqCi*!eh?l++0~zXns@|E z+^z5@5gyTnf0B?PP6@Gr$IPbTc?V(;5A~LaROKmrn=*6`){FX~lpmZ$LaLOZfAK|X z=QV_=mnXooQ=3t`8gPO+kWDsV2I%*ia*+QJt=FcPY5Mz!wlVJ#NvCPQ?ux29BN4}+<=!mX3^)1QI#4wiJXZZ}Xi+X~&f zaR^6KauFe%({V5_<{RzwT&&`^F)EtGRbp3SPm6X&3T}30H9pPz4|F;`)dHpx@!tw- zdbQzDf-ED5*7Ut+NSS{Jemn~7SW$x1Oevj+d$tBC?q&&!xEBiIxWcWo%saEpyIa!9 zx^bXv#tPlK2?(RilZh|UQOh##@<6c6jDq>ZDOa3RjaG$sNi_i$=UW^27-Jt28RfB7 zfNWA`evNZvPC&$MHe`+8fzeP&0SU+(U;B^GC2^a{WMRXBxD=3jf_#V(p>nwj2eJ+EfXhCF z!KEQDiH;g_`D$B`OGf2$*^L;;GR?;r`$#b|z~#;XE{WSLqi`pag;L5UAXgEj(c|(U za=9Pa;D2uJrx?MNZ zrb4LHB1ygo-lQfc+cbBF;7cuPW$yd@NHO^)*r30IFoBU)S%P12j;&$AI6S^>d*TAKNH+~=9pi5WCqw+dDmT@p) zPNR*Y?><*JN0jx7jucFEBP-8ird_(=O(o(dgQxkGA7OJ2YE(S(P`A8PJ}Zx*U9p)B za37BZBKSV{Yg(I4Ltj=CO@ul%HZ0797RuYG%M_+N%H^rhg$nXZjqJ)aG>}~+oTUlJ z$z#;<@)-H79Df{A`E$NvE^=N>fjjsVz{h_e@~#jGory;>G!cIT4sI;H3C0Z= z2IO{^^N67p1P+#c93spP&`od$WVj{6Grx`DsW>R`$ySgFmiL4hdBW zROo%gnpfZqE1JI(NYTjk&5&PiGGrocR$D@<{?st?jKlaVw}Vj7aqgUz9RG6Zwxfk+ z@_~;q1R1gL_u&6={BrnB#}<`W@H+!Oq9;1x`2Sucu@CV|@)6hJv0(kz)I(sugx4;Jdk|4Vy`!pP!$KGR5jY z#siSjnp5>VVbtp zUo5A$WnHKo^vZNmGPHsqLu5MymTBuRkQ`VqU-6G2<^)(H@O3KVV)ZBD;q!HA73%}r zE|DoBnL_9CA>TN_K4q*RE0-<*_PCrVi1h1|v&m<0zffYv>W8C)wZlEkp9a2zq2hB3AZ zOca|W&GsT;X5pTly!uOqPB{eyOIDsL4^hk-h~+$a4MjEa5I+(2H1s{bCPMcq%xHz# z(Su>yJWZ>{gF|FKORmRy>$mjHVWd!SSwi;rBO-oQALNHlyf29dZ#Al44Jq0kd-?0T zc7L&jCouAuk3Jk2zDdv5V^0aMec`rJIB7h8OP>x)`8pDWAlZLJdY5Cwg>H)5JJ#vU zJwX+d6BWFo%<9AX(nE6|EWKmD3VQHF221as-}nm3$3Ak9^1R@ypaX|Y?hoMYFW{Z_i)%~dgwvOA)Dv`lD%`=cFAA!Iro-Q*N zEz~A-SX{_acQb4-eC2)WKz|G7y`Oy9EnMkDtEkH3>nSYP>VO#bHA1m*V(bj51W0Q}t{5Rl(?9)EhDZ;w_k zD-)IMwyX0{_rzY=RytX80S(RY~!K2)2MXKoogPP$=L71k(a8K`>ar z+7b->meMRyzzG(%bOBFAYH?l4t>Q=tS9x0EOKg+@V z#dZMpG4#!R2p0_bkJtPs$YUtx9QMcXf~OXd)}(2|2iCu02FUvChbc0VHPpl0wLpU~ z7l(2S6y+A0Z9X584TI@7?Lm3;U*jWhhEugdfqm`@>>x!i+^9zxpr?-r$G9`BxdPBK z6wl^XN*^7%Ym$iMZh4T~h7H2;U5P6bT8c>i1LN})tl5I$5I_x6a*gP;kvvtCe`=HA z`WJWHY2L=b2H5=-w%(zVwbjr*^4i!Xvn9K9@f%Q>mW$0CgBm_dc!+cX zEiY^)P8@oj)m|2!M=l76qzCD-aXF2{yRIS8YK;Eu!DOUIt5>{UuH!+_m|0;n$+)oB zES6yJb>vpf0*cu9@-?~#su+RtQZDY04iZxmjX#{2xp4c-pv{g5#kxxX2g zZH0b&wD5hMJZvMG()cFJmTYWo-khRqwF|+mxeK61f-}B%0LLW7@uSi>qKRj488cLL z2GJomHk56rtY3v3rsGugCl>so^;QnN@W{aT}m(DnezEky>iF(92|8+v1+F#e`I z$T(_wN(78^rlA|{em~?}4k4DAGUVd|dZO~LfQAHPpO!U8t`EmCKY$vouOb_d!}5_0 zO6&Uhk?TEa?L!ooGj-fhkI7@mWG}Fr^O541s_z7Tb2egf$3jwg5`X1n;W4y_JVxy) zkD>6ZqBWR9`5sg~;=r1)>iV<@L3 z#e@t~Ap9lJ+e~$}S$U7Zj=EPKuyIoksTQl&qQJ}YfbZZNk7Yv<5|I`lJ4^Cao-Ge6 za9k^64n@7u48h(>(x@LO1Pci53GJu(#=CrZGcdbh*4I$Ep=K?xkQ)f1VT!22B4R^k z)eZ@LjWLN(SQ0|nABqfKmxtBeWaS5V?HpRc@;|Hq>3o1^2{3^plw{~Sg}6Qlq4<-L zSJ0QCgMsriy^S8L%`3~K>`tKu$ZgKhJDny_UNQNFcQl#@J zAK2moRl6HOpV&>B{yTX>2)&Bu1$`2GN5E(zx*Ip? z;HuF@$S613Snqj&^E_tTe^NsA2mc@_=l$>oBQRbbBInYTIzG~8hp$V7_xiFtG#@qz zn$_|csJbGUt)wYE1Q_O5_6Tg~aXgwK`pUGv-zJYyx64E9P!$p%(!@(NG36)Lh;pO- zOH}3Ad~nOu2PkYN)QndVyDCQU`Ij5tWJTxPWaAd20Q;) zCHhT`e(;S!mFHTA-ug~Ts-dFOQAH3dNg7Q%$)aOAR~ksIugDE#LQ~oB>)-i)P%wYP z8|v;gc??1@a4@k>nse>gpD!+|54h%K<_Nipr~bS=nx`wxX+F);`W#TiBLp_ofQKmJ zxAnb79;3FCho^{pYT^)09O@_5p!lmAgT;RhZzz6N9s?HNwh2u012}Xafo0efYL$Gj z+{w@)#dIYfRPIrR%KZntN>x~m2dfF2SwkXJ4U;kryE&*#gKL$D-QSOG&>*J5-pBHv z;PWq^!NO7L^NiM>SbImia@A|(211+CTjKi@UjGULFaucMlC!cnrJ2NHW3fPnQ6NoN zpTx>yw`H~)vl6}G*v@zb7HEBA_k8j1vka=M-)&v}?%b0yVuVN_K7g2-`jiaKD0rV( z@P0z@9rGWY7zp8mQNUWl|8nbRiO?v?SHO?jde%+oGhwVCJsG-2Fgt!7y}1L?gTJT- zAXYyX2z{fm4c^f7wv~r8y@8F!+!I)FvHBdS_!wTn8!)^o55Z8{Ud)xo5xP^s@8ZMS z3$qKFR1OzUp|W~G=QDx2V;J)$p$l_Z+W3H ze)83R@JbupBaOPs_a8W^iMGMHNb`$VSbDO+3eD3W+-KtV&)2?z9Z5z0#$=r<#U^T9 zuf$Skaw1koE244`8Xd5%UIGtSFJ;xzET^$Uj&6Zl`zF@a90hT5K+e_|@aMj-fRA;G z>R~ZGf#nc>A7M9H-I>*F_F@IVJAIk8L9qkd?C{ds*gtS`5`d4Q-D*7FZie-;Q1w5> zoFE1tGcXfxk}n~nF3H$rejrr8y?vpkaaF{o$;wMKS+_edm<<-W?N7;Bv(1DdWG6n= z118nog;|O8zTw~&XBH}e)jly87Fzn;uoZR_-0l^4c-IhtwUZ=;t`P(2D1E9Tx)}a<1i)V8*Pz{PX@BU`*Vv8DU(qnfJpNqWYKO$29%| z_2bp2d3mT4l&?>=KM#CQ)q|J%-vlf|5Cwwv^B2^Q`O}{O52p7Jy(!GM*8WH6En@!l zpf}CZ`|%arO}lP-w!9hc`qeAw3hkFIzx6L;Gix}p8EE4>v0_v8ZKy7^@rm-Nyd95a z`=NQ5b70M+Cc`7-AxtG_)}XJrd>HzQqmjKB+i8NPZkRkOPsL-|cw*bB2pihuozH-@ zSbs|TFPHJkDL1}K*t_HC%yUPP*Z|&D(FpyAc<8;-m%YNfo-x1tRz4P%20lOCtM7Hm zXOR*4)XAfAJ{~Hcqn;a3K8I}x`Rs#wDVEQ{itTMo3Zh9KL~J6T4U4crJ{LY6lusKr z#0TXApUCpA9oQEvUz@N}H&Hpd9S>XoP<*NQ;`%>3#QKNg6_@Wc#WqZ_ol0z4|3%nP zz8jwkmhUeM{wwAC3#R($8p)&b2|ToXS2$BvT)u0EqI~CK*Jg3~<|($F72CzcCgnS* z2ph_mc`{hOk1qY9<@4HZF+bl>ey+moB=l)3@`DNJGPBfKWLG+`nVkVPN{om8EB;BN z*q{RcBnAH9kZ{;84#^vyL$a|rB&A)E+uoFFyh|RH^(gPM!|94V4ZCU86n$F0EAk-* zza?FfmmbHQd|`X3W&i5@5g7tVS1Uf%iyTH1J-i1DMU3I(GTL7c{F3at{StJ5#r~z* z=ivBeGa|L#@H*i`Z}D(k;@}!{6iNdFDnq31{lKWAC@i1&(-?I01|2Rb%%7f+!epUA z6;OSwCWAMaTuz(V5BiA9Rc&1^^a0{>jR7Ti-gbU8=-H>WOQT@6*FJO_t|f<@ z{P{@W^Yq8!Lk+Py;Q02MbCCs3Y#2R2pjk8!QL6sJzw=QyTOO6)gwiZ)ptjrqi#m|D zJcg~^CAH;_jI7`k%5!b{a+};{_`jtuuVTGY^kpBEhn1Tgj!O2_t)M-4_dRWc2|o7) zjKSXbbm^-Ue+N%dndNi5F=YpD;pmJ{MKqH0?tAL;p$2o`)1FG8h6GOVv##a7r_+3> z!QA)s0;d{M9ewBo%$nJL35=A0XRKI);C)XU1_%%evuI;5dd@P4(KvEs;;VrUYKW|L z7b<~n61X-%fbgAhgJ=?9hG=S$K;7&^4d%Y5ZIpnV5Zcerx|aK%CiqZ;x$o)GmqkQ8 z7-U}jwJ)M>DZyey7vA^uh7UEE`<_l!0+UE!rk`~!_dQ+YLk;G>r;U_AEeU+x&$^cT zp0@L$26Nxjot$p5_vI}8l`o=p5m623vXXbh6O}9{w9*c0z3+Rv9!sB5d*9RT4olQ) zv8~j@&{X*1&_=oFsrbI9`;cvL_dVT4NPGFubsCmxx=h2O6LAfT0-mp7(c_3OU)kUn?N5Dv44jCsfyviiHgUaX z$1vzFZQ^lT?h-+VaEfM?1GviqSp{CRW`kKrBdhI8cGs+oF?R>D3cP0R31+42hbq-R zPQs=ZNo{N%$SUxfl{M%wyfw0Njt30Cq*)nbej3Os@S3$Nn6=u^dZT7#jQRWmUrYk8 zS<}I+f%~2sHLKkB^k^Wfz-!j_U{-e38!E$J)2xg!lLA=MYF5R=^Z z^o>APf!D09!K@XaF-)o6tXUajHVtGIc+J`p%sSN18q=(dF~b5`1zxi*4rVO_V1-iM zOS3Y@tU2G8u)u592BhWP_w+T*BlkUZd3gqX-&5VUqyy>$N9M)i?9JqK9rrz5gly}) z@2P`8sk+W@N~aM1IXZ>sSD<>5p|d~Y!|xP6pe+7N_dUG;j}EN%vQ+=Y`<|vNnMq2f ziI272_f-B6ELm@wmMq_&FS_q3c>gfh*Ervn3cbD>5|ewrhh+|?Dp9OM-^U|ya1{(# z_3|#nnO!9TIbxYw(cZA@dRJ50(kN(;pmf@(8{FUnf}dL(3J-dPJjOyBDJE^{%zOrPfQ zSu&mcnG9igb}PHwM>ZE+dHXBCIM+piZxm`>nJtOW$U43hreu0Pz3HXt+4kv`<%_2kje485Jz*BtqTv#RqO zKOuVs`Wu9q)fZkq;}f&O!&Eq5LmlHZK2~PJ%Vn>jY*fKMf0*6=92b9(&NRK(Yu?Lf zwAc}&8%_tFFJgUjA+xx?Yn?ve*<%g{85CA#tjwYEjWNtt#nKJnD9fWkSg19!Dwue} zT=S;aLtsS*SNNNDFUDKGsY4Is$t!QY{Wwnw!F1)v)u-IAKe0Ewd{3NBXfV|rh)})% z1U~bZtZrA)aLH;JgMlThZnRC#zoCtGR+*!h+R2>UFC`1F_twkV4HqJJgkzOE)1?G6 zj_@)bSStC0Hivg~spJ>EWI96D!;AEyWuQ*D)WyZlnE-NYSbQFVA1Wd5*NOLAZ5q?_ z&X>bJ2lOqlL@IiBi1Y_`_3dZ!DZBMpBbDjj{QkkMe|l{cdMoww;{8%lh6l(ZD3nBw zWWa8SYjEqKHKKp6y}A7J0{LIpaIaa$z~J&X2J+wO^3NW8{>=jU&v*F`DwV$~(0+Q& zc@~x$XD*coBAbZ3Vm5}R<<3&Y&d<2|UYF4}i~Qu5y=2=g z@{=F&l7r0x-%+5wgH#%%Wn|5XfID?z43X}4D8f8+9Q@I+-h?01_=Cz8&cBvuAM@&ef^ZyBx`3`yFdKIKugZb>4dolh=|y#W{Sx%dp!WDCo;=xkYIM> z3pXhw&qL}&V-AGWVbBF!t~xNo0V3AHnh0sFm_mnjJsL7l=7Q_n0sVlLhZ+7vH@ghg z)>eg1A!uJ=$!(vi<>{qm7vpmw(0gZBMoBs7@zkA%MIrMu8oxU=(wHXf^MY2`uBtmW z>lNIiSjE&-Xd;))aac<~v6l)R=H8KvvdUK>y3E$V=ZR&MyvX-Hjd}MT0ZY?#e9SUn zjUrVyf=s+^Um*e(;z8eKP0tJ%8;Q@bc&Z;!Pn!BUP zQFj=^Z;E9ay5%UzjM>fcUlW_VdQgfNWehfmp`=X+hL^VqOmY!-ciD1JLeMSoL}c|IX>M#=FdkKdrLaB13-(|YPQiwt zRET?W=ui^aI}o8s*CI)d;`Zmhh73Ux)4Zhc@(A{oIQxYCOgOas@4$A8{PJje|A6U1 ze-U3q>TjxY3Sj%wIjgc2RQu3fZ}EY4M*}Ul^fm-pnqtUKeK=gL;9Br6+@8 zHDhGNP4IAB57Bmz5!kYSW}xby?dWVsQW(_k;|SJ-Mo15ms(XaM?=EpF`7HvdznZE7 z_lfvO{LM{)_LhiFY)5oTm*dkd@9^ID_;cc~(NyC?bHCd*s!ck`&Fms>CXk!S;0A@P zKxu3qkAfJ$Wq*+LvOqdvQ7%S>m)Dy8(USl}A55#mz_9j!!@Rh+1n8J2O@hW0Sgl{Fs4{4)ImjubdHfy@kh1F?6pDMbci zajwfGJNVap3Pb7jsN&y*h5`+hZ38glCEY7MNT7(QwgNSH`7sFoZP-Y^ke;4QZ;GZm zWPWn$@0~zF18YPQ`Rr}3Ocv@Us@}e$+zf-!*~;gBUIE@mpib8p)UaA(!vPaQ;5 zR0&$hUkHAwN85U%D}k?8Iqwc|&ak?KTR37)UFjO8CN4DFd)4OK11;=7(29Ky{E#Tt zi>`DA42L7QPG6_jftX`g)jLYz}ndljF}InW3Lf4w!xz{$eE6FvhB<}@G&vq}vlH6E#9?C}|GkS9Ew!-^d$DM%9&DQz zE3!fgSZR}57F3dKd+L3e;=SRBZ}Fm|RkL6#ii!pcnoN-p!{CW4+$v1x9W9cc>#xfw2<8{!pw z3FRXxD3P1%D#EPeSlGmcw&KrAGN7vU&0?t0H!_8^G5SV{sgoKK! z;iTG`^yl1Oo@zz`VrHB0yzgSy8hGYARN`=0ZBHd~W002Hfq%9UC{@_x!4O(}CNpqF zfp*O_{Z2$Q8Vlh6&3KZY?oaJ3VmC5=g`?7^yg>2XHVfILbU6+HziL+o$i{dlFU!BH5%A z68K_eCZY9^syVpp}R5zn@+mIB7B0)=N-3cvcdeuhN6OrzDDc4)SWKsJUY+XI?S z;NcoR@r@F-w*dt|Q<3!b`F5RQK{As_(9QAP_WY*^-ZqKCyv(MDxIXW1fr6#tE$pGO zw^A`FyBjMd6QIPfP^u709L_Kc&W|PdZE1d;7SjY4nL*`8Gx1(Ls4|YD=dLA_*j(Kv z0LeuJF#Ea!=OSb*)zQP)vk~j^UF+pz5+>ZTgedp&RR#*gni@)J9jX%P36z0hDMJ$x z+QycMcWJck5H{6(-GO`zOTOy7eC;-$beJy-kMVRM8^e#+Gomwb-umr|DpH=I2o?qqFf0fz6a;O|3Ht!?whGIOh{OynVEKC<%Y-tg zYz3A(hx;6OEDuqNvjY?v7K+33Se~xY)#?^MDFos(1Nj)1e9tZ>p*G2ocq9|Q0xZ~e zvRHUdF~%$eQz(X~8J9AfXa=FoJzIk3O$&GyLve)Co*JOdu+W|;w4FXo(rDF(YRxt| zkd0xPyyLYdFE0LwqFK%7=|CVmd0`7aZnZbKla z>?EYP@umPf3=2C81TQOjCbB^GW9b_;G*=)5kc$b3c3gFu{};aPeJ_3j&*;kc&s*{W>G$^sro+7!zQE zVPRqzad<|nTBB8cpAhu%nm{&&C0q9u%+@CGY)xx0jI@lGDaVX43&2va_EO9y27pjz z$=AT~Cg3;|Uj=ZLf$>6b`bc{bgk}&5LLmr*!gRA6G$2S~SC0hqm`0Mg3;n4pq!Y?2 zfs0oKO2@F2?t{xQF@&#gjATT>e!ax_6k`(=xgQ0P>bR_rlP6vaOe%r000D-Dz^{Qw zz058$`8*_@gSwDOL4vLm@ykS!-+9V+E(Q7yLcfdwO0g3OW(6cckXgv?O05hU$DoXE z{wYkvdlBh~Gb{}L?Kh6WC1h}~0E0Tm;_S@LiX`Fk~ zMq7e=6i`5h0i<9_;d0f-Doz0IBPJ=Zq%au_=seW+Qq95H_RJlyq>n%a;pHz0l!JMK zOA1Uwt1?$9XlnqJVVz~4?NnJlVv_@#p7fk)cvi#`ZwcgQSVZ>10-6S1q8tA$;{w*< zk4#E27S>@r@dgraKw?I2$I8_dB+Zp1MB+n){3D?w@wZqv%usSKv!m8#C)+3m(+U4t zGU|HAX2@-NoRa5WCfdy*S6jP*C8={r$6txStajoL$a@s>LfQ)hB4BuV4H4Hn#9nLU z+QuTfdFBwvE=Yw7CU*VL<UKzWok)@#>&~; zh`hSClZameZuwawbeT#fDN!-AS$OV=l*BA_*SWX;?p2|gg50^?VbtCFK>SAH)=A~0 ztSPXCh8v7b5>zG%NAItpOYJ6_O}Kg;{;?8A?+NhlUHg6R=~IvR*g~-%%y84 z^8_>^w*#pcSqF>P+)9u+G@85|-A(*rQ>UBt#qJ+0X#h0aKKb0oA)!%i9%9ir>kyKV`pj*8jB4~qORD} zlvLhPtH_AAY62zV&GIH2ofc}4ySsRjCCD?kW88wWoPqWnjGr&n+HAj^TX!j7&;*6G zH(qckEU!ntjEF~}yCqwp7+YTijR z_h-^8vV^9OcIO_Z(F!#KHCwZIPbw zz{!CEGHeSd!`)8-5=5@08~Y+kmqO{x56SRnED_ovxVC$e;!VU8(rrocNs3e+u}lkg zJw*{?9_t~klz`&9<^+jJCbztZ9Blu&Q{s4`0+t(&|=W%KZ_alDX5XBc2 z4`ju|!fBKIrhT)!N}7L%Ci0TBHcT;N3;8n|R{tr(7i5)_Rd&0)Pp?Yo@jS?XzPk>7 zxK9{|63%3u;B*4Vp|N+%qhmoZ+#q>tWOMOcaOaiB$A1L!#ri&XoBP(iA5-XMr9iXd zLNjYNA`*KynUT!|zXUB756i}|6#lX?Sj^J%W`5bx{&Vn^`=LM=q#VGMeM_Z$lPTMl zO4))b(%T}H41iIbT1)<*0k_FD;2E{I%Qe~C<*=?FwYSSH{1sZY`*HW{Qw6_!@xB;8 zrt#`p|UA_jAmR!+Bh{32}1FVJ_0V}SkTVMvgMSA;l9 zW!#JY_v<%7n@7?l-l>tsY!1+Y_LqNjBNz+pFMr3qYrWY0<$s(xO?K)LJzdzZXe^gyTJDFLd_qzoy!x8mQ z)z54J?Nr^_*YZ*M2_DOEL0Osk4M^M0i-*-he|!)CyijP=9FAQ1PqlPy=YceALi{UiZ?(Ssq<;fP zDBO>mJSF1!N_W>~#Q{7l3FC)<_I@m1o&(YU9dKDem7u@w{8N7LdWPSbUpI(gqCY>(_l@N?}7DA?NoL>&YL|t8(3Y(_eZ`2&zn6B?@5}0 zH`{hKK*XG>O&g&7(_efC6IkGPt?gs|`Q0qY@5n-acPQdF2P-!qzc^1~KUjCy{VeFv zE;i;sd&>7sP#19FuYAPQ<`YC7!{zv=TG2(J7B7HgEPt zC?Rko$X=1pPwAcfb6G6?SOUE@o*KgU<2FK&81;lEEUNddqlS|H#$?J*{2_{QRy$nu zS~Go!AZgF@g4(SYbUdc~&6-(&NJN&<3)-IZLiAQ4%Qq!HvwT0WVP55nR~Z)f$-wQo znOh0Bl2VO^mo@i8*7!np7PUc)J-*P?QG>TB292|+q!J!WSN zpox4O@Zu9cLn1xsa5yh|$xevT4fK(o@FmrxI|ZM$PKADNF^rF_3eQDXfny>L`KRdA z_4Ga!0h6m^nJpQya@pLzS-G6B2t|Gq4FZm2S#HY>P{XZ0na_M&Wc2zclu>cE*NS#S zqD?upkHRRirhCGv1M`^KEuWdcUV&W4AQx;6HT87Jm1c+PVIqpHJU2tIjTI^R<=Q?U z)ulu=(nEzIrrDaCE?t+ifZN^;) zF#8>goRlCos|$Yj*1~}Tn>XZz%@(-u*+kG#TSx{NHw12jd^iM}OBZ-x?K=8ARinG| zwQCP#qITUiKXMneYd-5A?GpE9N~P_+NqBjm*}n^SSJOLcZ*I(J!>Gv@)YQu%s5dTP z$ul_roiQJQoQMf+Dw;yXOc2U_fDMO%VZh{4{tWvej_n^%LBRS&dd&sUTA(xHp*;P4 zeKAKtXH_23H-NS|Y24@i3&lT?^NNjq(PVja`~ekis85Q;{)?lz?YWjrU_POr)SRx0R=Vb~IBC5h z^iS7S9L&X49?Z9+L*T)kkS`YR`x7;gD`ZQbT4W5Q*8fc+$AJFtMKeLM(xU+arz6G_ z$pp_IY@j`5e+2&>m$>5$Hmb4r9HP#cJMg4-{)~vkbk9YnEtP6IktW`EmK`37E^TR6 z7R^Cn=p3hqBDyPw(Ihg7+IN8fx}zCg$%(JT{#kC`>cg@nj3LY();1$+au}lWJEZsv zi^y-@p&#)4YpEZO8@vOp`SlkZkFwX?iUkoLL-osj?^!?pEuW;G9ZiPPe;|J-GEaMQ zP6O*?iHRPoSbNGoNXut3=sFVkMrbC|t_-e3o@RXKClsEyIbu-AX0*fK)10^)LsZ#Q zA+AsYx;=Lo0aKxa-1~TaKhnL6c}<0W=H9o`^h@0P2z|fTzDM;?cW2~*GV{Pa7!zgO zM>;WElZdo{rxy7h@p9(Fi=0s0F&u|6v+oV%vA(mz@zXV;6=rfJrdGqLAGrurbU&~2 zZ%zI(o;9yyTGCQwA9~SPw}1iUsB?T_Gt!dVPx4wp>xC%%GKV?!Y-r{$0*S&=t-;i6 zz!A&gO_=lW)uEZ8jO8EWXFs=OPqS|hjL~H1KezFL|F9oCNvN$53pR6BLQ-XzcuLM% zY)+YuYCH-igY&?rqdIY)O#giRuEFni{FdS8>0AE&C)VP~-6xlyCH#3a0?t0wN_%yF ztIoqrSOA(A%wPtYIjlCnfB@u$m&kJ|;3!7Wh+wb@(`(GrVA<;!_ElkI*>f+i!He0G z*xcasSxKJN!=tc!kS~r{UqNKwT~edwa7?7!Kr(&&iLnkQ`?!NJ3fB_Uxs>oUfP+*So+!*ZH%+ z_fz1m;%hsp%I~1>3ojqJNdgYL#;o~`i@{u*OrKqqf}kIza?vMQO-JH6Xb;{nkMbKP z-r^E_&4XUbY^Gd-luX2+4q(L$eYMnGtPn=9LbOAU**8n@Q06?+;WY5C%}+eEdor<3 z6IBPk#TOZk;Z`*20u%{OWU|rVL(FhI@cph)XA;Dpw%9@5VTh?n;#=_&7U4?%fLAfY zCU+1u$4+j{Cf6nB4`l3F|I^=rwd2olqDi7DnQvDG=Jl_Q z_;~#I1GWyQHdQh8CL6ZK$DPqiWXTdsU*7jdjQz|fdtB4=a~7HnYi1RCBh2sF*Kv5; z&b@K!2{6g&Rc4PL2in>(0x+v@`8N?TPe{8&F)Zj)T1p)+-03GKr&pV$Htk!?c$ubg zGWB}I=jK?t{A4pmiQ^Bb4yV*aI#NH*$2K*H?LZ$}6S0v5c}g~n6y4fF-W{eYa{&K+kylnd$Fug|Gr}!ql<}~G_*KAzwlSD;O^82_ne6$?Q!@?Y5 z15n;9mkdy!h94nTrKU^ri1~=QJWui4-{OSUY{WTzYzWZrG3RM+^x%=KIo*Fro6m@c zH<5|Yl8#P$e6oH~*qHD6a9xhRh3oR+dd-$TT(`Ls_zstmHE?1i$SF@5{!dF!KBPP? z_8WYQ^D-N-$}j9yY5PVS_ieq8ENI_??V)IXmF$RQg7ZCIeZd-3nYR@NMzyHEY3I!+ zQY6^GB!okM_rb|vHF|aQlTU$~wm9FvqP=xkJxMa_s+le z=>bo%J+Ss2X^#I|sc-Rz>8w$4_&pYJzkA_+oABJdSp?WclS5aIB-D>w64`>R#{6Eo zL@Gk3*>9R_9m~Cr62jo;qP;oPm1C)L4Nl)wzRn+~x!H{5w2&q2Sr8ugc|9mrHBcYg zew<9X)<$1?MK%;o?cK1f3b@T#wQfVF*A8|EQzEW{`dL?dE|#bAN6&`(Lg!n{;^gh6 zm%Q(9E%?mX`&?N|>SsxOw!cP&p>8qlV2v@mwkosHA|T|~E@El4`r`WokHtreYzGTB zi%!%`FUG6Rk9J{oy77(tL$zdfnUqZujzraA1*t6T!No(yHm zv5;vX0H=k--pj|WFP75Mz>+39Q~{8evwn&fselsg!!PeS^FT>Na~~step>y%~Fy)JN$x^)`}}_m!PA7hY#7wPI@6#<1j40|E9je z=ApUBuvS#sZ=Zv(X9fCDBl2cjOj3W)IF37o&q%NN=L1|Y42-c3!QD(ED>5cEon%4K zJelvw9cg3p`#;A|s{Y0cV3~V>F>gIU`)fEZbO>bTD{IacKIlJEmDn*dj9b;z5ESI6 zJOF|pP2N0h1A+dc!Ph5guiYkw85CrI8bayM^lw9 zZ~>pkn4KJ)3?e3?RE_441W-kK#m)H#vx?5=*&oV(EQLC7eM_=EQT<&&Kpi~S>~kCX>|nId_+_9wKddh~8!%;@nQ0=J2uw6o!9 z6KUO^MI5xvpKn!tRDN)uWvf)Tr;k?NQTa9=B+50f{PwN#r#^G-zGUChE6p#3DbCbH zV@Bi6S~R$D2YGK^yW9)wH$H!U{T9ks>{Ee!!Eb@RsP**2<>v$-`>_9U`v$%PK^v z7;oVV)*?AaSpL%X*-vNvTqVV23xhB?zH$c9jwgcca}eVx znMW6MY5BM9FHjy|pS?NA!tv2wS~Xd-i?|4OeANFZ)T}W#2Zl#~I?;I;4@)fiFEJp& z;nB_81pR4ekAn7VZQ~MRZ|$8q?eq(}dUXL^ol5lEUbJ19 zROr8Y(d_Pg8@uO?V$^HZ?Rg%bQn>-u?S9P&zgh5m8t+T-V;X;f@v&cjs()r}dje19 znpCRp$7l0V`34@kC+=5H@la9|O@>-80|58Lm7@sMLHp4-cxr|FMc0e|n_Tcr)xE|k z$yDVOkN)Q;`0^qBGDrW+No0h3;?NY(N4)(wd<6P+qLHQg=k?;}DCOq}<>xs(R32v( z@H2BE*?>IW!T?!&aC{-L3SGKRT|h2Qf7grt^H>*wJpRP_!&K!DJ^Jq+Umy=he;Vlr z9xd<8HtSk#+9p_Tk3@9&Wju2T~ij4tZOj!>yNIiw*Y9=fi%%*ru)}u_9k$ z1FH# zQ?@OY@*qyl`og+=P-~VIY0ncBqsa(V|_+h&C(3)s1*PZs{%L?%m z4vaaKtjJ4ew7=7QqM~G4i#b%%X0%`$8f}bAb7^y~bm$mECS*k3Z6+#$R>%IQtVLi! zvjhoF5Ni>-F?o_U=fi$zDv@2S69&_1cy)!eJrTKI==@5jBico)H^8#X zzryifjaQ#6f2sYmQ&>d<*yA~?W|If!c4;@=YL?&}56atW9xyBiJ8V>FBkB*Elfk4p zbEt6M8co(p_54`hAxr^SV!kgCtZ^Q(`-{c81SRXhP0#BqG6Nf#( z305(4kixdEd3=%i!Z^p+C~Vr!3+48bceIMj8IYC3UUMsN7!{$UQ6F6p7^KT5L;?Mg zPq2ejaB_}op>Dpe*Us0q8#ol8*4WORVnT}hNAgdFpy28MAI2<2?a7k|%V*2Og%XD^ zKmAt45lFAelb7`qNz**3hA<1ntY~AnKI<4L7%$Mb5?8!vyd9)pQ8b@##|!J6Z)Sau zrFIn5xBcEhDgrXt>B4C)t@ds%1)*qN(PRZ`s@<;2q^aJh`EK(xbh9}!PmJIE$UJXr z!vj(=_`U!e3(j%En>4RekL^KSHjnr9eJ0YZXmVGrDYu7CfL6@3j| z8mGokf)LxR77zt7d$b%4Kt8^KHc+L_VWDjfi=ki$Ph1R@>NdASrEqXtbr^kvw4B)% zv>BiXPizKgtNFEn>Sijje_0eQ8m@}8hN~Le!<$6Mg*Ry!qb4C*gZOU5XAxf&-lWVt zt31CnS9x|Dq=qvZM{)5u;Zf6o<^v@x>~B4LqVu^BylYjx=0`XptC~nHzINk*=gY;O za5c6>{ZhBRzQeO?D2rkB;mNYXf|hO{HRxf-i6W~}0xq%PMpW=Tl+80WV_9B$HFjpi z+@=x0-)VMdTcp{ebjSON;Vu>(9bK6lmTnz zRSnfaGgY#Eium&DKkI5#>VM?g>wiQ^ej!iR7wbJ*jh+MYY(N~?#h2lDzZt}nG4J8l zu2S{k=Vg1JOohplm+F?SE1D%t#i>#uE{fJE@6~wnopvc-|A}90Z%{7<1wc#K$Ncr{ zUb}ux*>eZXx1}af>q~UO1&HV_b0Rit4ws_Z9ZhsVpjcTbSdaPORVh3)fuh)Z1Sj0A zKM<_%fIj_B?jhBwG1NMwfGu~iOiMH|v&xkJ4QVoWj60PMaa}656Ho`N z7{0lY?tmzyU*+0|=>D*Q?J9zSB^-dffoKLm5LE6=4LjgUk|GgsEyQxg(T>k~@f8Gm+ z75VFbE@@h$bCQkO*F|Ct*&L1+8Nuj&ZPbvi{zdHur&YXyLYp?DfVHXw43^n^{Tj5KEe&5zw``JkF);nlBGmJnd zUeq2bzb~8a`e(7xw3ihym(n+rU}5`f^7XTD{^zBuIm*ZU&pps_XhfQA!kmMKj6m8= zpp3+lpKUrAA;;1q0f`|5?BEmFqK%qr@~2C@D+KOl61Q|*{JnL~|LjHTZvLm!dy)B{ zuUCs!E(XmObGxMF&;R@tau#dm=6~80L91iG5nAP1{$fCO+ahqHBW-@?6^`>ipVF&~ zt(@)`$eaK9n>c)sRoelBo&R|OxPc7~$#0LY{m9rB_Lvoy^rwnZfra&_?bp@$`uoST zDIiBy%>d?CHWZO#eq|T}CFWPS`yRq-b@MCl={p#<^DBST3Wh|#$oxvvwMt(}LxltL zE6)#MjbckpaDL@s8)-Thkl{!RAoAx|u5;OB{6u{0?l8Z?659Ed2eJK(Vbih@fjKKF zn}O$79ztiOhRCnK*ebt0c|NlAGimm3UwVG!h09qy?H$%RzcNxb%;wFnXjJ6?i20Sn znx!_fwxa((pI>?BQt(sYzuWUkUtoUaUsrwJUuu5kI=088H^0KcrYT>{TG!jpIKOfa z-;*6W5N(sG73{oT(BLc?VThl2%$o@0;_STxGapDMolA3PhDxzOGg!k4n2d(pJ(*s`d<#`gzNuxK*$tr>ifV>*>Bur4j@J-=`P2@P(3 z;Rpf!qVo$kD$f_3qdb?MU&uC;m|t)m#bEoVAiT&nI4=8tb-v(7^(-tph5v#1g7;y? z|4*1NNT7wP#bbM&w&t?|_gBJk7{H&d5$9rE^98T5Un?408N0 zA3mX*KdABlk)MCY!qnRF|9?LFD#!mL*>(p!?-8_TU+wt6vQK&t)J8Ti{$DNQ|C3l? zJN|zk>)zTK6pa7>P3| z1p}Jo#MbC8E6ittd>s4TwJm|I_;1OdY6U%vbKMjlheM~Y(`-W(4Xe(Z?73P zf?7u}Kr$P-e?c?b{mZra^{+HoM)MyEiVYSA-lgXcIA$~f)uke?O2nfkilso zHW*ref3c5G$_qJi3&h-AnH3g+teSEu9Flalf}-oO;htOc3{d_WRZF5rnm=S;9cYh1d9nO%KqB1(Xq}6^R==`y;T~<`yaD^kW)p_xL%Xk)AqTNN0l1t3ZCqAT<-3`_)jL` zIQRC_-qI%ew6$_Q3%$b4=qgk)Xv5|O_hudjaE_}1d8_EeWfn6DDS9)t(zS<_upb;p zpXoh*^8<($Yv%d$SFV523DIb#fjg$lg6+AXSU$dumwwEyZ#0y$kFizEk1hbSP`n@{ z(Man>V+FIv3qu;yZoOcD{7ohE^CBzYFs|!`^D-0>U2^^b6x!{iMcQC97F%JHa#yPS zVhjAaZ~zv!Kil>=SH529T7G9=vu4=apZDW~H8A+Jwx9k3Z;f4v3VS;lBC}?w1$jz9 zJ{FLt2x4~z0i@i5K!(8bp@4J~c2?;b!C45{r_Jt-!Xo5s(xRo2XuXVUANZu{l8wmTluL~ZLV6rQ~d&~{!UzL z`~6=p-&KBfY56XuItK023>J7m`xGo6{lNs>paZ#}?9SuvR^U&D1uGt(ifY{ zC4I)?z_xnu&|=1KAYDU?;J;>P>jMf}E}bsj#l>*x^jkymwk7Eo?wsG8DI2O)oi0lR z?PmJu()$%bH!I}6ySYP7m*su9x1gJ4aU{7#%STvahG>h%xQ2e{&2Q7ipWxxI5_wXV zJfL+eR|#dzTDwH(huZ-Uo0_2F$7F-eo@Fi+b+n zn@(hIAcAp%+{GqZR{B1Gt3cDg4f7htc;yw)j9a}a{xdY=zyXypV4sq_H@MEhmV2mFvsc_XO&@k4OEH7WIz<_R3H zj;?}YNf~4k;272aw5bh=2;jq`9;dLZG$EKMyBf05p$tGZr`AbNuB~tgMIAT|`2G6$ z5vhso0Y2;(-L9xU1~|{qv{Kc=9Q+vNPHTg<892}Io|Xe`xfZ&YHm~V>ueaX*j6@9b zJi{IYrUq~dfQyA`%?+9)4K)d@x36?*!S(jLZKPRBb1QS0SX%j1S_D?VAjy==CbJ;^ zdVAy!Eh=Gdb69$5*5|C84Vf3tAA0Q*`&C7{Rl)g*b?xU_pZNy6KNEJM*ggd3YmQ+1 z8F0SF=eN}S3;A)rznf2y$rRKiOt;7#TXq;8B71hEw3LgRAJqI1YA0n?YCI`;DR9)W z&d&Jx-Fyb@ok;>IE#eK^i#Fi?*K^QnX+qtdhA-|W5m{%TU@~k=WWMA6KJa=_s(ud) zjm=bGESOL6S|YE4m4Aiyz{_89J*rqAnmqgN&HsvD zkOuuPwqHZ`@7nV)^F+q#J*<7d#t?QS{$34rE!xd3L=Zd&lfPc>>eJIH@b1>TrGCY3 z2KBiH;Hr0`EuuTrs>G3z<&As7S6}o_EFLvvHc$A$=0u5S9Zarb4uJd>`csXYgHg$ZVZ%N z`g!fswvQ-|Ht;Y+iTgRHWB)!9WIX|T)aV@~!Xbt%_M|V7!wkDbTJ$8%La5mi)F!&x zi7lYo3fFky;aJ-;hwJP<*nq0}DhC%3Dp%;A1?}$?%n=S`e?9*HOXq1yjUR@n-gZOL zdd$ZiqQrc`c~S2rZ~X9QFB-#z8Qu$Fy4)Ryce&{NdwdRuT`*@c&AC+h_RpU8Vw0lF z$JHHd*2Y<{^x-f+wu%UF8lQgDeMI)4OR{k`s;D_UMxzrrl)@Rk7Q+)#$gm`M z?!Y@9<TV)6nckY*G#KX*wP>618PcQjZjZ4hQZ5<;%j$+E;1OyK3cq#y=C! zFk|LQ0l_F8O__gz?{KDYgk5eJJDKlU$YT|<3$n$JtCfwokpGE29*^$wthS3Z{c6-b zk|yH*Gard4iusflR(jsFc~y{cNxsG0qmu*+F)NKF-H9z`q2xp@`#z`oSGpfW8jo!( zAg3hFSbDbutUmhos)pZQqZ5_ja0Ej|4okR5Gg6#mB;@xmlOaf<2jFftR!cXHXE*IB z=%d)!p_iP9aAUjKOZb2_MT2pkSqn`oa-$k(^}P;!vJQHe^n8|o-yr)BSsyR*zZyLM zK-W*Rz-&0DAfsGaIx%3S+ibj*v;w@KmSkoGEXrunzM}o$cqyj>?qP!|mRtjUxP1F1 z{y}N^ty@~?CMn2Isa|F-oT(8ngJKk+wdz~Q)Jo=5LPS*F)7w3{1wQ!ace zFr77{mHRZf7dwAE)}x(S##lyX^w8^Ivgjo}px?xL)aygM^Dqx9>TYu`EK8pMJKg7p z;~IPsVFyxo=V3m+#=XdSm|=P+!D4XNVqTIo*}o%3oD)YE3jn((*-OxEPEl;=Je2+G zFl}tvxA&p+qiEdI1VjFJuWZD1EH8T~eH`YyOv0R+xdoFpdF83`%2Q|`KLhf$+efHv zqnSUvnQP$Aez5)#55F?`HAuP7K!Kp!=mn)26zR*r^ap33AvutD{;tkHS^7s;2m_Z> zaeW3#jjsy$r=9@^?2sHg{f3mlj$V_sW(}$YZjIhypW}-(P246wy~4Z?g<&GLS(KTl z6q2Zt(?^=WFwOR8`Sv0>o`Trd@;!$JkuL`m+&ulj7CIvY3R!4H7b1R78lkFKa#rK22a+dJ6S%MH0TbpQit`+shZ?p!!odgeM zq5CKO8P0o%8yEUcgp?t9C|W9x<3hk4?}H=T86Wmpe?P9viO)o2CXN}fey~x7Yr5{@ zL|dw(2{Gnxou9e8F*-EcR02j*ZOjl&EfOf>LkV*5ItG|~#bLGt8UPQEhXjsP0yQKs z%g@?D_|Et^OMn?bK%nONP>NLvm>>b%FV~Op5(#{Q8bS&BP(rh{pS6SVo$)G5fEhqQ zpmy@1;(}EPWP=1&10AGF0@o^mZW4ItF<(T4?~EHn1FDS~KtP}#^P%E`RSEP22|NXO zEFzG=ca%UY2^{NZ?I3(-JZ%Xu0|*Gz$v#wEuquJ>Ac5Zlo>NL7@J5Y@Xf_Fay3#KJ z;XC7t5nYZFFarn()Q|uH!Kwthf&_jEcuba)z{N^n5(z905FmVKd^(~jB4z*qfx5|u ziVIdHkPZ?!3h={}z^+Q5mIS`-XYC+-XFO^NFarn()B!$JT(ByE_8@`X0ME@`D8bX5 zj7xP?kicIb^+iPZ&UlR_zziTDP+141tqZwblbcOl%fxY1te<8lnrxGpuvprw;& zv34o;%jvi^4i%j06ZWMKi0+F|eZ^;!!MSyk+QAphqf>`xB51-y>1Sf9=&)ppKZ%}C zN~J|hc2GskJ208%B}~GHM|k6nIjfeSD}bhb2ZtEE{;y*a8(X5ImrXX&(SWy1e1H6f z3P45cmT{^ewTLn1t+e0Z1wNLkK^_y#ItGBY$BAoJ#+a7^Sp{CRW`kKr1JL#*M`%{Y zm_G%w3cP0R31+42Z7)%+S*14i4rCR0&B_||%E}(k+W&uJlLN}i7?TKO6?o0s70g=g zXI-IL8T0?J_a1;zRoVaec~dBnGSWrLfS_QVgd~);3?*m~!z{suWiliKjHZmqBoKeB zJBlERWmFXGv8;=(x?}Ge0R?;P*rTGNqQyJiSKO9hzY9v>!3BUK`l)| zZ`48g&enZmf-3(y=$hD|1dr15V(_IW%vLm5++-R;X7NmJ{D2! z1X&gca{aqyp824BIFT5D8Wxh%wB<)ex% z-B=Iv3UaU;5Db-9d0n}TZ|Ta*{vsXFA@8!M3$jjD$@M?zE_4dtql8gaFP+2;|D{v- zmMi6%8@M8)Q&@RH14nr7Wq!pljibg8xZyyS&RvFAz({-@T*FUim1euyq7-ywwJ6G~X|4>pqx>**X%_!zZoZF?zd$XvgSZ75z<7O6NN!MJMGsZfspu3%rztvJ(IXU{q3BFS^AvR{I$O~>iXNlraf;4W^h8BZ zR>&D7sbA&lTOK=vRt1 zDEh6U-z)lqqCY9RUD00^{Y_EA6EW;rQH!Eo6z!&HnxZ`v?WL$q(LRdyQ*?l$gA^UC z=nzGRDQZ`Aq@tq~-CNNyitelE{)!%`s6){VMKcx6R&;`*lN3Ez(L)t=Dmq2cX^Ku) z^aw>~C^}QoJVjlK&Q^4eqQ@wDoT76TU83k2iUt)uOVP6xU9RW~MbA_8d_^x*G^FSy zimp=haz)oDdZnUQD|)S>HHzM#=uL{=tms-rZ&ma*Mek5Ftms{e-lOP!iawy|LyA74 z=wpi3D!NY54T?Uc=q5#=QUr@A8(U%o{RngZK-K^+aioT=hdy3X8`k|s*6#Yce zt%`oG=r%>aQnW$QZx#Js(H|83Nzv_!{;KG2iqbe`pNd)(?V@NmMbi}Rp=d8fU5d_D zbdI9OD0-Zta}_;N(UTP|P;{Q6MT(Xx8dCHUMOP_$xuRy@qIW171}#`ZRQCgs9j`5Is|;$ukyIEVPd}{h6Wz(1x4An#W#oO`o&IUc zTb@QM%z4+O(P!qod(!9`OWw0-^e=1PhiPDg?S+UqUx%-Ny_;xqC47|m3 znK|M^(#*16)8q#-^t0X-i!IIKv>awFip0P&TaK}w8i!;3?=ZT#tz}d+R`N4s?^B|F zcNjK06L~$;82+R|H3qgFRyz3Ws8C$`L%KVnVOU3pp1wZT-I}#$Fcw>y>BQ=>u8O*M zMxJAPz8ekC`E4#w^Yml$ugWwg{j1WAz4z??w82lKn;k|E+J|VLJ>4|rFDl$0 zVc+A)OXThGy@{#@uQb!g2LJrQ=zE8m?lkf5b*8>AndvptBgn$VR_mQsy4;!{vF{<) zrm|)E;gE0j({a!R^4%QwQ)zX7#-Iw@2L>%QE`%!Jum4fq-!SNeeqR|Buq`vu*~X)y zqaDUTx)Z$l2G%M8f3*|5EArZ0`YAK`{6`+GAzY+8=Isk+c_>=AM0fu29zI+?N~ z_V4J~IdU~)_HO62km)u93GOE-h@%VFEy+;MvOJ07HWOkuzq0}FQ8o$ z6IF58tOrEnV7c3Bx47P)4<(;(?6cXRyA6-X(N?``rLC~cvo4BF*LryOmm}F%_7kgr z&U@P!wu1SKJI!gUt+dKgeTS7UKxQL#5T-+$O%pD(P{{lX--X;wcQ`OoOWUEs@ewTIHTs z85AJ4x=nbRa785lXw*Q#u5i{Ta#N78i3;kvu z{I!LyvGfgE>3J*P-)8N5Sr>Y-3;+JAOW!SNw7Odl{9fB_@R_^O#%_Ht*^QQU=R22o zAN=rcbZ_^*&+SIvsXJ$<4gSw=bYoiIC>KrH}<0Cz4~tMMOXCtr<5n_ zKDJJ>on8;O>y3eEOCB%|j@Y&}KWe8tjGk10F^Ltcv%G(e=%?EpYk-c2c3RX)PGbV* z$#s(2y?Ob!*C!8&Nk5_e#Ml$p6K?yg#Wa)Kh#f{Rsv@e|>vn^#FfdjW8SU20IGKia zj~jcmu+dnVTeL%+XlMQyJDy3G*$9_4Y@;h}XQNJE+h^!Yedysn=b}J1^d0(RU;3ag z|Ngw+&};hBIsH*zmk#Lh(*RmEVDLo)>Fxo}n+MW&1J-s`x*SN{!Q5!rzGwRwkKXEQ z<6$mZ=(+ohA!owuCq`_dJ=~ixQ{p(^_`sk?jHx<~v<1U2Flf2KlhMjntS8Rc5N#7t z_SXGM?%o+}89RJ#wA{HIXA{jHzL-u!ipWC`auPX*&nLIWzyBD7?Kxxb!WfylFIZAV z9~q-r1xl}_Oa4Zm8)Kq)hV=@AW-X53o>Wa#ZN1H)Gfvd^IL=Ys^P+KH^{NStK-lQJ z-JmVTrIw3L#`#@(tnXsJri<;ZF6P_2@T$f~yY{%MoAGqly@|f=Iubu`?`D1TNaM+F zR{Vam+s_>8>0ZxRp6YG<);H^c{^s@lGGFX({cS-wZstAowY?veGyVDqxUBhK2>{K}quf6b7rPllS`9g@{J)VzA=h*iVPZwiTZXJ&n!WxhLW@bYZ)v)P%rbN2YYw~sfk9*@k2 zCiGZ2$+&s~L|->yB!2!jp*wtBGl?^B?<6bkJU!`c1Crl#$T(!pev?tGI0NvBRKSiBd#)V@BQ4Bs5=Ik{ss+i#u$VDl)dnn z&*Y<{`6-n39y=yv96x@s(VK|pP1BJWTHa(Xl`w6MH&j_RdrpeA7j_?H9TP3c!Eb?TaD4HO?0El`i99^ zYeJjBjR@&NarsjRxKGU+a^Pw#GjDChlWLq77Q3``EmrXU?R_Gjk{BlWX#v zBPj3aqbN6TTF!AadD=9}|Lg2Io^*)4!dH@hkiX1V8mKsEaT?#Pwl}+7t!|$_=@9sJM?4=;QdaIgXz>a5 z{qb+oq^y&aCr=_z2YMF=$~`A~PH;?`lmX8fllDh|{l{gTl;+uQ%;J5k$DUkRSzbKm z^b^wew`WWmH|eDPS==$6v17^QDX;L_eWm`&z$81(_EuCD^A9@Q8wmJH7uYA~&pFVZ zS61Y$fG7LHvf?7#g@>u-UXSv?Zg#RS@&y)xRaDONF7}sK9B7|fSzhif4cJR7OXhjY z?Pc>hsss^Lc?$z&<&;KaJjFgw1)?5{-_TR3r^E{s`DrgL3)ttERhAa9yRWp!SLlWB z6YMmJ>~xYHckTG2d7cVip}Qhb4ms(711btVrKL!Jo~Q6s&QGO34R<|-g8 zYxe}~#lBLneROe=eay(w6(bQ@tfwOHd=KJYX*@gRlW#S*d+A%kC?!LQae9g$q69p2C2)9GRT&33!U_^NYQU?Gb@t zFka}O*zPSaFDpObfYLHMd~+;H2~<`Y;IxaXp(kIVy~GQ9spc}Ou67r4;dtFzt}$cV z^vmgW#AkKDTY)I&d5R+W)@kZ^#Fd3#0G0SE>>_8mr*r`qr?R)AsKHfKm&_|Gb_c5c zUh=akmLIr~0%fP#4>`mR<}IBxY0j)8-Nzr#`dqTaJ|^y_QjPs!<<-9T-W)5{R>%`5s>}B5KP-7I*{h zQnVXM6}`8#qOv?_z%Q?!(9eNUQcPIKQ@HDxUB3{&q7GlMKy`;VqZmofp;;XDJBJHPM!*}7kYIY z*d#XDp*%F4`DC9>_QOf}-H-S>~F7x>G{#{!}sWlw%qoIIj~38c1L`2W8887I}=L6!s-i8MPIcD_FYt2 z$Z{*Yu+OX3-3QsnsJ;dheX7SAMKEEQy0^q%>?wrFl=uVHcHJ&=_41YySDX@rQ{&7y zf(J_VXEGaxDFT{!X^n z#a~(%yHjs|z@aYGm3oi`LkTPOq;Aw5l<%jJnR?-OPvYh7@qY$57#0 zK^lW%BG?1cCrWp)x~nO>@2TX+jEcG+jX=uIWP+vefBZ$=)DH`C#(HIKrs1+c2G(&; z$ktnN)=Yo-HvqErhxGifFLcHF>4#s;_efepu@VI7Oj=53(=u94=gZX9*j2mMh>2D^0Ltd zl~rV97kLBdGPCsvBt1j7TyE8G%FIC@PO?W+xGrF(tff0Y8f(g`}S_b zY1oeK{eS({vc2y}+edFVb#3fPCbM;q!Tkrs#g{g)-(EfK``SkB z)pgLYJr5YMU$?!w+l*cZ_TIfu7t3y=_wHdEGjhn#;bRX<-=9s$kD^^;DoHlRzl9zA>Y={jJbwRgY%1G;rX)V-~i?)~}=>}|F7?%y5pTk&;9?4ND- zK7IP)uV24@{bT+HsK0>&2gds4-!M;$+1#az*&wUMf}duS*@XIQwpa`^ZZ`ir{O}n^ z=FM{bbf?9H9w^ZD3( z>bGCCG=2rjN@JRQTBTXv~nn4r*$C!i82Ctcm^ug=qA${ z!G)N60S}!5{T+w8_tBh;EuDQuj3I8ydSu0 z8T18iJBR3C@bC)A$^1OT175ol({tdii!j{`P8Sos3U0pydSG|(?-^f)c;_PB)rc3I z)*xQ+;MI^1+;I)$1FyXn@q;&94?Td>jVK4ce-p|9+;I-h>z-!i{+`$VrpxnXjPa4My$zz1 zQ7(N9>H*%cC)!VN$54az2d^7$(81ufc7tYu`$rjcB6xToyi^8n0AB)Lu&+VqGX}pJ zJh;C>Vene;TE^JKz7E`$ZBRYm#~S|z@R~_T-wk|-L8HK3haz6&!<7TM!5uR&b%gu% zZiBXh(>#ML1qcV;58PRZaNwb8gEGPE|DQoefY<%apyR+PXwX7%`0{#wWj9=;BG zU|fUOfsAj!;t%F{VfNEJd~p9Z#LKt=`UQ7=1O4)Ste>a@ci;s~J$M6n1M{Du-y+D3DSjJx9ahkf z0_?jLTV3E(wjkq&rhU)%$??T0wQ!~2_P6?pwY@B{9jhWsKTtaW;lT?AlHnKxKZA&eiR8p^u@(ai*AOy7LlI^e8R5O*z7Osn0RIOf{5XUk zhw$UUCjd`^zrP@jzrY{3|6t%l!10cf4uiZ-_;Zp`hxWZLmkgH+>HHPpj>G-qkj@E2 z_7ma%M1*I462hNMhT~-1FF^PLq&pAyi{QTq_tE}`y||C|-&q2`<&dQUI;bL}25o!& zA~Nc$p^MXz{{KT9OCb9a_&WnKo&g>N55oOS#J3drMmvwT-Uu&;+c}UE?Y(^k(nEV+ z2VRHv-nA0xU4V3P*)Al*fwtX$3DN-%T?)Ue5Z5ZCk2c=1263%{zbkP6O2~61;){Xy8oLy+Sk#1HOx819cD{wE;oI>fU9?r76%Ho|=)boC7Iv%t?I&o3Zc9sIup z{xbZ(igaE@yzda|HRO2@>Aa6{?}OJP{d%PLDg10h-oJ#bUqQyNz`usu*9g-9-T?j$ z+`oei+u?4Y-NEyN-DHp*L$4qnL2JMZEQaBPZ8umAqo5n=emC6T9d)~pVbr4yxA!%S zV1KyxHw-^Mm}(e+I0hs9VE9LyUW2QCsA1Ub_>Idy!Y~{o!EuF0;y2oF|GtJ%yC3S$ z{)posaI9u>Veb}KIxzMI4UdCxXwT^{Xmbujx`)ASmSKdBHpqFbVT6wbJ`QQ)3LOu5 z%W&Th_tS8{9P(8_9<2BaS0b${!>Fr*Kdg8OF9Kc+e~aO-+A#cR)9b+UYPcoi6JwCydpqm2%}1Np%1SS?roF64R->Emcd`}>f$9{xWt z4Eu-h_aX4d2=@uXp$!jyiu-80Yd%9baQo+w^>bh>GphO8AP3rS`UblA4`lfPc|$uL z{u%ri@L%BPSH#r_-iWZjL8jl}54^@eTWB&7VPIa5Hrvt7WYnOIuHOwDZM3Z?cuy1A zdx2w9BDB{=upipeekQ|?HrqbHWVp~KJMCz1VO+J~!4W2-U?jrsWimpe(Y}s`U$n=e zgK*yge-4w;kbypa9MT*Io@p||nTR8c`*V{~Hvw%l+T)sOCSDQ)U*QY}>hWg_4ik>j3xs=w&l6rKyhylL_kJbzeM<@!dD5uO!(!( zR|{Vw{0iY$3cpJD)xxh4ey#B9gx3haUib~dZxnu$@P7!uS@=JNuN8ia@LPrdOZaWV zZx?=t@P7*r3%^tNUBd4cevj~bh2JOqe&G)Ye^B^C!XFm?i10^+KPLQf;kCk_5WY_M zdf^*{KPmhv;Twf-68^OCXM{g1{5j#z3x7fQi^A)Kza;!+;jajPRrqVdUl;y{@Xf;C z6#ka*w}rnW{9WPi34dRBz3>l&e<=JT;ah}%Ec_GUp9p=P@xH?Q z3GXi)!)E0^Q1~F>dkDvHTDk8je28!it=0Wu!iNjTFk9Upp|~T+DE7~Pp4M*&<5kvk zIKpqxxb6eZdCq{{gBW)*=W!_Wy)aY+4^p{~XC&VSKDt{?r2P?{vXS zgr6ZiD14>(J4^6#;TH+NQuqzRZxMc{@cV?X6aKvLw}jUV-=esKGZFU}u|vXmp7U)N zjwva|!O@}zBcSsW!FxAz-=`TKqc8Q){kYTMugN){`2$^a94^>P?N=Hu&G28n4DRs1G%s zjjKyva9rK`QR50+Kj13rPmM3*at@%z0|!#$S-8pvQRDnQ5XWF@?6oH~eu(RiAqYQ| z8t3Aw#WiXeHJ*p74%eXJhzHjlxPHJj#ZHYhf*K#gl{S(Z@4|KBUex#&uDPSYah*6C z>FrI8rhTY!Gp@VFP-Ac`@`P*OeIXyN<@@2Ucr^q08b^)q;3~?5 zTP7I=S!7&|s}7ebn~Vo=ZNqioc<2zM~&Ccf}Z|LjWx5W@whqgdo(q! zJC+)+JRW6u0`8wgjUhKRURXelGd;+|JZjv6>#;(}UWB}OQC9P*@z4d-XkUo9eb7Iy zr%s{9Ri~mXi;=Gqlv^oez~w5VMvEWiiR+BhsPQ*k!E$OmIDj~+U{{L~Pc=0@fa~+q z;eQDkxBd0 zHHKHgMlMJCS3s7lP|nvNuQjld8zJ96pp&(b?_Xpz+(wNoi2*Wy}-Yb&nbaP@hMOk;2zjOz$o z$KhIt>vUWzaIM016Rt3>T3mIw>T!LG%k(yx`r#V&HW`_?=Ha>z*SBw@PP~Ki!}S|Z zgm=4-E?wj+EppHHR#cXFf#>FBdy0Hz6&cw@-hjtfobC6NS9r_Q9VMPqz3!>AX3omX z$;)@RClr?zdIG+((wrm$9d*>?js`mZ_?%hOI}oVKQ(WnF2de$v3{ORFUVdPl+nt`C zG0#)sD|A-`%6+8^atrhFGjX$Up{Lv(DEIgR6}g2uNF&od(NnDQQ&!G*_;2h`G@E>w z@kL%#_p<6;pxUY=TY%{GOw%{jZwOL{Jd)SsTgeK8)K>5;47~%@9St9osZOOI6Fvz6 zc2(;&&Wq8R9#kdP)UHY>v%+_J+hww=Qp%d=UEnMILo$_BQS2-9MtgwYSA*>&6EXix zHQ;WmNYUDr2E2;{S%I=sy=^Nh;&oziS=p(cgQK+wTshlZE%@r^xJ&!3#FD|j+v(w-09m$Y3q7Uod0sb)u*zE=@D{lPWir{@6qp<2EHz!5f}Q%bg21%uiLlcH(d~Gnny{^XKH16?s*S zjfqPQ1KWwq6Q8~Z#n4KK33x~4Mr+~CUf>Ntqte6W2h!7v%NF3BkGH(MtbA%l4u)x} zro$zp*ju_FuuwZqOK%D?uDr4|;4AS)195xX$|JoaQ6+N3YE8XCiliAI^|Xv=q8W~P zo+7uWyxddmF7+;QYuTnYNtM_`jM(Z8SF^WS>FM6n+}!1;c21rJBrDClj`Nnyk4lp$ zuFS$Re|3(l5E?9z>?HD*?Llj}pcEcUBARZ?+w8*G(Gp4MPb(s(+!FbU^cw69t#6!s zXuylSr{QfNn@4Vk%rj;H7%BhGM;15q+6B?Y&iO^6i|sG@{bnNLY;K#}_#b{n^vbfwrr2z&*S^120j>$*z!WB2O#9@(WMRiK~sB$|hPP43)CAg+_Z?3bXk}j@*eRo`91k)2C z9g!1(;*3Aj?XK__`vUHHmGkF&%Uf@G@$?bfCh3t%`UDK;%SthkR9P5sdjf8*t8K@h zY}1~l2V|;d%rD2|9;RL6jk<;C9f~@p&UHTG=1OTPbc?E(ywr&!PoQ!26gG|*eV}vD zk2kq4C<|Rf%O|jm@o4HR+=YIB`gr&Jvhqcq@}j0-G0$C9^4yg_-HrdTV~L&2LI*VO zX{G}nTefd=+0g-PWW`Xt?KT_xMpjED7@Z@z$U1>&rwhea;RXC`Jm$IP#OY<1rW+kX zHzl0S375d4vVXs1Cq}DtQ@UC1896aoj(G_$Ezd5^cqZn@N znR$b(#PbF&NSDZ7V0)QY!y_i7RNo0ZP9i_>lGH#c-K|$GHfxL$&Q)P4Rr|&@fv0eIWsqu|rvDzs^}FUR zf!R%um|cAT({6L~-!7)M4N?k<4f4o{L8{{VlNe;v^b%&;P?4G@-X_LOyup6;w4iGB zk~C1BWfKF<{Zkm|&g3}LSFH+4rpYQm^hEU|V@fF@;EIN0Wm9pNk z?7!4oj$i)jreeVRj;2vurkiUXp4-sw$Qrg}hi^@$6j>ynU|2kkZ6Cwp%uZD77P(7M zw;;bB{qDT*35pHR{M;a8JyA?9I%T0P^3qyre`I1iomQ*Q)}1j$Jjk#qX0s`F>{+HQ zF~-ZPk0z7v^pjd!$s{n%PCl5ml}aL`+3Dx7P9%sD+Sv!M&ZN5YiMEw$OG{BDh{kJt zM;k9!Tj?Y)mGO~QYUeY3nPgF;cP>$$&JW_yiplvMS zK;`e4emJ=VM&F9IF_p;+IPeyAegJDFc$GWmpE1ytl^trDMqUU)AdD{J=iBh2UxhFC zEm+u@2r@AHqarxfTOG4}gug_@L;S8=QIZ2e@xt4UWTFwfruuLV9LShU8`k2O#O)Y2dThYgiSbgL+ z>0@S`J}_^OmuhbQl-5&-7X|JLe&b$>ufr0*g5xzV?(}A_u;#e&0T@~b^eFrs5&N=- zUoEKmG|yA)L9}kqd`?BbDQ&lAqYlJaFFu9vC%KLbYnNND<6>>0lRLgQm5gdk-^Fr{!&e=Av-sfh!`3*jnH~Kw=zUb=f&c}-N z?tZ-}AoksGXXJ}{oYgBJ+~k)6ImKA5t6a0B1%rv{mqht!O>^>RU?>zf_W0jYTU&Ym|5wIQE=`k= zs)+S0Wu(224z;*TNOx40`gqM5mguT6Uvt~ww=Qf_k#QnNsJ|`2atF2B!xS`nnB7x< zJnoNecK_ry0`YX0r-#`dEdFAhw5S1XR5#Qb)DQfRX;=T;xgLjQbn;ocdm%5m6bs-d z08jY>wW_;yiq{<+mTUZ&i% z=|nOZX<9k^$yvtlI-FA4Z+%sG`|IADbwa#2zO$VWUOaOpi`Uc?9rSOjMh54R@$)SIyG z>=s*V#a(|;EB@b5QG!-IzP9OUz9ic8oFv=y{6Dfy|C6Y+opmVuxge%J)W&=I<3Zi+ z@j$HYC%|Nte(e7NrSFPoMVC9@^}Bbh{{^GWz(aH7sj|fbCHmM_>ikiy^{}uzHqQ8` z1Z|A^ak8V2ik9qU-PeeAP#@y5%)=Z<}2x(kHcRkBUw*NUB%t+o23R*>K=YAZD=nKEg= z;z%Mntyi6-(&=~&!3r5wX*+AT@)dq=Vhi(lD$0|!v5NBaZ2qb*@-3zhTdw57G*n*~ z>E!ToUhSXFFSaLQDT%k7U;bk-ENe-kU;HUM-RVpvvdrHvPk1NZW}cLNC&*K)>-V_6 zH?0}ajdRky(@w{V4>);Y!Y*iZFyk^MVa4u{jBQkKma~-#-mxUw?IG36YuIb66}@BW zb-cp2(Is{$>1^yq#G8pFYHvFf5&A3HAt6yz33g^l+JX~=ZQTa2fUy+|NEA&H<;*K0 zTP@{8adx;YJ+oE&l%PdO5Pe(amB4%AQi<+w$(f(M(CI(s@Yn+wmxf4u!a@Q4e!icgTctp$9Ve&y`0yQ9+$YgjHZ}+7>bHc*PWK@%c$ef8}_GfW){Oi!R zGb1zmJQ2n#TG}t?-y<_k!?3p2N+R#F929aURZ_BEQoqY+{ev_$5vX3ZqF-g8;{V@N zMgGhrOS#$SN(rn8?IfFx+Ey%yYMW$)yEwk&qHDEpO|+^%$riE0aYjcm?KHI=k2txe zwT+KD5|uu_I)cP%fqHwT-|?7}i`SE=c<|9h`^{J@A^E$C)&fU&qm0{K2YVcI57cZs zHbjzWjdUSzqr!`V;xycK%TFX#WaaimtRvxQ;yWUUi$-}) zIwX%7Uie#CXqzC(mQkt%Rg8GRRUi9JjGg`8MRCJ8@oc9zrpOOW#ESD0UnxE%QHy5h zpwwE~6R>4rCdd@4A{s}0%NFOjNfflG*rl>u zx`-bI+?aI3{$%d*Kq;fb#U5-Qr;f|QhKY*{y?)+(JnDkIbbWycQkxHB8FQd;VdNGs zhmE^2pTFB_5swUBBcaqtmVw&Vk$)^$yx5I>Rx8R%v6o!{AKf_kuHN{+aN()gTGPk7 z_{ZE?P>KDC^eqgJ%l-1xR~q?+`Aqy&+w8%eAQa~Wa~s%665NNK3CqCMp1$+(16!UW zK9(PJQ90&Dh(FFjJ@Zv~0)cA6&abQ}aBoRr3E~FlX-xG4!*;?LU3_5QD@0Gcdu^ah z9Y3H-HGca@NIZAWF?qa!U*Y1#o_W5i^bGv2@Ih!4lG^kUD>3JnDYMAKCb8-95o9h} zh{c)Ooa5u+uR#(;GADl*SbZdp1Xdq$>Y&x*fK9_q7p^ueRR1N8<}~rHkyX@{cXF*-^~6r@bd`|-y51NE`lXSH-I*(R|6sb>gp;w{YO^<)#df9h9X+GX z284or#FUL&w8=D~x>_x!S9_dk$0|DCjNO)LjTzE>#nN!1Mc#Rp5a}|5pU)KV(fyFO z0X{4gR#LM+J^-M!tco609yRjO2k;qGKI^{V7`3ePssr8%wXx!-MzMFXUO-${T}2_2 zg+gC*#KF(lyOteWa?<4{m=sRG;|}CL_^Ls45aL6owfC~$LKq>A6OkaWgNo_7GtpzM zGZkT5fF_rgN?DE!*L=V+)qkR5eNT(J$cGBgdofF#Ekj;n)~`%rw3tBYpCJD57R1>t zo%TYJAj`9xJ(^C$ZnM+Mec1jvhiWY-Bd(5Uy`Hj+#|dj(`%36J%LLkN;S&0fHIHsd zpF`_bLA~KsEOVXGL{R7Aah5-FoCJ4mJJaAJeEj>X=z$J7^s)ugJZnV}MD4&=T18J< z*;ss~u1G1+XYf;_?SOrn*<#R6Rngbhaxc|%VgJBQ0XB3&q~CBpRPJ3>C3IyM*l>A_ zpU2>*=51vG9JM9J?3rRFRgplfb6jKBb;W5+c<+cmy{!H9|v$NRWjQ{&R1 zBNe~sX0Zg%?g9nXFN1t0F$a37D~^s*QJ>QtK7w$w@TrsZO*egbA-$d^hwaf7J;u}5 zJuQ}odv-F1`fS15yEo6GzW+>G$MdK|)}^8R@8wK3fHr0F?(TdxoI1AgOZEc!p@*eA znF~CpRMB^7%`>5HU(loDc~Ai_?E!;C3BiueiOs^#X~=@|@o)GD!p4w~-`FU3!qRYD z-n~7V%a5B+_w2az2=*e|24sTlJGe?kZ0zA4to|zc4DLae8I3U-a-3^Oul0bg=DtDW9PFzgD&V5pYIv;MDLDfdImN0hRoNrkon=> zYKkl-7hB*l_*GXnyK7r`|GaneEM5v-1ixmF5gp#w%Qu6Y$surqjCJGiYhwan#U1i@q9weO;v|=V2PoyWuA`-9t3{vK38N^J8$- zvlN{(Xgn?3!(yp>kc(8cjfoGIdt`Sxy-JZ()5k ztm6DePFcc7dRO*|9;5V7AEf>Zrye;Y15ar+ePWJ>ppV$gH_f7Ww<(H7xHo(TcZ-wX^d$K=@=rK+^;hAvv^-XvR+qS-_9FHKB8Q&m3 z(s#C--tG50oxFA_1Z-$sz&H9O6z~Fs3O&koxb`XTRBLdQJDD9AXJ65u_jA9yKX3c~ zV1EqG;DW)@znI><1$Jh_2c7|UDaP#R2_NqtcevXY))q<%bVJlyeyrk)!S+A4clfTUPDeedZu& zcs*;d;S#Q|_3M;Q?_-^-?&^X;o>_4fM(u@9_YcAt8)54oRQ|)5q6rGqkZ=r!CA z-WiSI#l$iEj2L#nXXt*8q3+)tLyMES;2dd+hT#JwcwB1my4_k9%z8ELD zv{#pJ+@svB#z*Su!=2;t(RUml@=a;!^sX&~?irj#+xEnWmmf!6H;v>D-ai=!ubq#W1}OMnYK|SX_SU(Z#ICV|dZ89&b5KF;vDDr_E=&_^6HMvrP2!U_Rg`w$aF;PxizpeKj{UN=SU6 zlb26B2CE~IAFRjr))M;{ESt}dq=@!S}G5;?TgKLKS~ zL-AIRpKYhovSDaQ|1lh;a5I;J+MzvN zO~b{QmA3dDLo;~C^j2Kg4?|tx?gEckEGw6L4m~}L_m5W)LgYFZ?(M_0x;PDgtE{i25Gfto?*l5WE9U=9tVsG(4)+_l8fU6?TYrJDXYeJ0S$`!=OVZydA>4(_9+>50zgyD=S-tg=AA4)yTsm-Fnt*ejjZkILYC6_xY6 zIF_jbd04-9Hodqv@_89Tm@rbpkz{=Tno(7ratZn9DCm!4R8P}%<0v(whhv>EXNTsw zm1q7013Dh%wP?t07|lHy-7y+w@rxO1Y={%3S);^J#E+_*MXFzGtH+s)90tjZT%x^bWjT8{{klVvK0KBsePV10ZREf|u#Ca)nKm@+5=nm>Q$?5W3rW93q?Y>ox%-Hm zKYI1P(Q`ka+80OXL{1ZZZeKhQqv1iPrJ5f#sn3)7H|!fZAd?#4C-{SkEqcJ{=S}fl zzF$mySMP@*F#Ll4hnvOlWhN9s(xv(4ekJt&ekjM)CJubD2`blC*!~5Aj}>Xxg}n8qR37Q%{I8^Ak0HX z)PT80-9qlPI$k;mMYe(qE_9*E=s>AIi-2|KalqPhp-pQ#oqIr*9^&o1P!4W=&@ZC7 zdBZUtOXbRnG2p@{F%Ea6H_M@S9aHHu2L%6)jW+a)!Lt0yv|+oUs(lrGyQc7=Ohm36TTV&5K2EDv=4|j3n2GXLPmOiA@%XplQI3`0 zfr+?0Lwr;hn8l+RvuJi{U;E;m8G_>6ydKmb&s5xlDMx#UFeW>$bnNSp1TtN^|n) znL|)39_LbtFTR8sQ|tG4X6G5K6NouOcEcgbEuj28&qUpD7;56DJjl~KrKwd>&DQ18 zH-C|@x9B$~yl>`e8n3Q47AMEA!pY~a3!3(nMJM~+VNF_S{o}LfF0=^o6NCsp1)0rx z^z&h@E~{%V;rhvmmU_pW)%wX~w5R{T6OpC<{cfOj@4-&2El&5`Hd#*byl+a}X`PQu z$)@+GM5-;%=3w%xgc_$ng@_4xc$4F<1tpU@xO3eUeK6;n@DhH23q?M)qfJv{PUQS) zirG?=%K|+Bfx0xC*`seKXVCZ4nt%RBt8=r}%V<6=Ir8ODyo%`7Ii1?Vw{C9dcJ6(B zuGvyQ3AvQ6t#(=#y*bTn2~WhmNEi0%w8)X0U&E}YWbWdULV#{hyD3eT6w#Y#M6iD7|}lqVFn^yY%1t)Vl8=Rqg#M z>-5p#&9i!OF0y(nySixA^bQ<0_Y4At-&A${c^>jaKA(<$%!>&iY{3*gB(5$u+8#A| zi9I#o-Wjbdy`?8+p!&bfL!a<_+>XkA;Og)>*)8tj89d(PNd9FPLB|4Pr`J)mjDE6qUt$A%LsJ#QE zzJh4=8@R`)TL%G?QIULR0bRUuR8#kgnFo|h)3jdu=ReVBvrsOh+A$ksKy6g4O;(=- zwPjWUt;C+E^r@>|t#G6>=sOomW*g=vEHz(npU7kJoj<1NOIPA!d|pFEscYnP;`i%7 zn$5pgqL*gI&l+=WyJ|M1eFEVv9p0xOC*nYZ=oU~@uwLM@+2dQBfD(Tw&m;K>bc|S{ z=juF>pFqbLh0LJkbI{Ko2%Xk%V$IfF$#Vj&oR_mPA3>x&Ql|k)dla05G0cmqNa*=i z{M-aTwf{immOT1lhKpW3hF9v-`r~*h27P=y1o#GhX2+G)?97>Ub6P4ZzRmvZ=mg4& zZL_~RI+3#Qxdd%L8kOK+Hozy28$YndHqB{uT)@t2jx}3?(-T!!EbM_@M2|$d^wnlz^6<=DsPseiG;lVz z^P%Nv=ewuV(y1AAmPhZMPw&p#nVr&?&F{=k;}n{oP1l?r^L~wIEgcaVmolC1`R#Bmv$=k0`@ z-(G}{?b0OeoXtg_^U=yd6G@$w@z0_d`~AJnxY*%ELw$~kOKcc-6&Is3G`Dti#Ch{$ zkAHZ6e$1n*9__s{AFaVk?iIr!Gd~P*I|yy?CJoBI)m|{W_WXl4=eM?rCx26}wqoA0 z0NFbQqM({}0US8nA2BShaOD*T=V7*xw?!^oD67sL;2blldMZS`*Mjk`eQo1E~m0&Mu-RY8+H(BsZ9(uPJyl1Z4k-tLlHfYv(<&QAPJ%O3~YnP&Q$V^nRLPZr_BO($I~KQ98Dyu?HK$`}^K%z?NcMKR97!G&^5fy)B3Hv3)*;k27QZ| zga6^_l6H4G-F7+*y~#-0-J105B^};ui{~g+4^8JSK_B}azs?B#+@UuUPZEU4eYG zWL8Ie_6y0+3RhF({HP6>IT*WkeXR8|j{dS#9ZYRyR zf<~fp`~Ad9ZZph_xh1LJU_k-rQD{l46UB+E-q}Wi{$5E<()9>XbX8ei&y`un%u2nTKBD*`(C3K47?5_Pnd6L`|;(-`HFL5a{kX1aXG(z z1)>h^XtPE~wsJh{oMiGHvrpqyD>|O*$R>=}vtYsBxEj~L#kB5T?jmYl;or6Ib4P)v zyO`~#?p|S_Pl>-*uOj)eL%m9(jinIr40;d=xap<~FvDE;Hzc3b4D;`@*WlgfLXzl8 zLbWYOYui9YcMYU(&x1niHYWWj!E+>ubb+cLGlu2^arw1;^Bn}Yod*#kuQq?5t^H`j z`CKi&=Ds(Xaa)_){5^KQ(PDqRYcEhH$nm%TBKLuFjYxL&up^P~(B#jc+b-m2(LwS1 zJ?<=Ht@u9|=zbyg-pw4Ku1@8Xeo5eABYUV>%au5fK3QS7=;@1$R`xlgZ$t3ha1+|P zW) zu<&r?IJ6R-1Z}+}4Y_FkUGA1kj2t@qQtYAAu!`N|TeQgXH+5+*l~&b!pe&!dYkGmdFy zg^^smcsa5eRA0z8SHl;ppoW!~!Trpw`~_`dHGH!wqJ~G{)l&Nrymnd*_g&Up4Ub;l zQ8lbbjx1{-vBmNjQ`)2ov3c&Ez8tyxjB{V3j9@NpGnXvHrfA;6N^A*C4%3XYGbywV-6ewqEo;d*{8^e&qeWf`|@Z3@JaG*^mCK>*sJd z?RL9^|LjhCt;K0~xp2eoP$X*t_}ZfPKS+u*h5B* zS;Y`GY7N9&fO`&31I`@K=2wsd+kg4N*9pE=SO0cRHL%4G7V(3}R|ZFiseW;GPM|2hBB+f``mV%BBhv!XsgX zXHDWaN3N(UP^AGI)L(Dd5DN@nE|$FBa3On~ZT-K-fNUsUSI7u@Y%m zJ!`F=c>!DtP%C@8LM9i|0#pegAb#PG6{QLwXezMRLS|>!2%C_Os-Fdj*T!kHH~jHU zKM0B;Xw;h<45z~nB`evX4i}4uJ6a-J4TLb+aK8Y*Z1x(%#ZFEqEQljRaiV71LPi}I zs?Fte;vQsVz4?(bcxClN;Z7&QA`tF4Kv+7iQZAQ6Y(klYlLI>o>`p%-a-v4C9XAZC zF=_omjruQa_H*GNN{2se3YzMBIO~j{DP*#T4X7Y&LI@L=G5@igP-y|%5=W0jYk`n3 ziVo()#ZhbUCI9`du;GUot{P@a20w&`NYEbt$Ay0`RJ>Y~pR>Ug2^nw%O?3te%~1e9 zT=VSqnxo*$>8LRQ230m71pc8+U3Lzt{#c!?oLW<;D{e!11;~g!Y;n}WCsM346*Qno zgGPM23v)vD@ZYc01uNnfk28b2P$LQqzfk#*O_Vt|nKn?A5p-u$+2G%Nlj8}Rf(FFI z1@UT3T&!%`PFNG<;3V+Z026c~04R(HMa4B8PWT7AaY6>@rvPH$Ho~Yt$R9@)A5onN zns0#R#l#SapdOipe+YssxL`-nHwp~53W8`PoCSzDWH67p@KgT}A#V*vTxE#lAK{Qu z~%Rv(a0l&&ACbH0?ND^b|ELngKjnt8lIGs!|%pJ9*#e8m-- z-*mO+S8p=tHrzk)S-FqzNCp8v@*j;K`C0R0&LtXV1j&Wb9-bNL7QsQm1J2X#VZjdz zZV=parFOTWXXo(Qf*pb%6YLWF*YmZ19%QipErP>>7hRy;>jkG>DDn5u{;w766x{bB z?Oq`GWx+Lq10n71?5)E;B$#X(zb)7<_<)PWzu;p87YKeLjb|lxIwV}dhOpaK*x8HV3*)G1p5UK zzd_;`JXdg7@cn`d2I}~}7wi|DeWT<@aG~G^!8L+ygLL>e1v>;EbdwJ65`2N+0>N(y z4hnYsL*x}46dV?8zggrF{Jvn?L#O}rKef97Voq{uO(YQeHO@jS`e-IoJJn>fT zKP-5O;5xw@1=A3n{)m5R|8~LEf}Mij7wi{2;Wq6*BzU=CJ09=3z4=%$KkhR=w{U2xBPwYy93BEdnyI|MuS(&4AxC+Q15SFlU)tAay<$K9{}hXr3LxK{Ab zg6jnz_khSdN~d?HV4GmegWBCM_;SIuf_Dh66MXSQ65nVY--w4bwh2BD#jd|GT4US3I=y_s4#EAO(e6&c+XNQ~KH*vI?ic*2 z;2OanKd0Rr1YiBU#`gVmdi%Vfu}kp#f`fvudr`ZG1)o}{alPQFFKJBs>-c)Vtg&6N z{S}Raf}a&!o1y)$cva#Pe8g)Kew=nUy{@rS@M^(+!MSf}_Zq>U3$7D<{bub>nL55> z-_+P4c)(j4y9D1QxJK~Ix3zn%VCy>?HweC7up>*yKj~fVUZ1V;k?(128?W&;!4AQ9 zy|3L11TU`FI4JnQ4>Yb3{J!8?!B>5#-RlH@ESM(f^zuK_?l!^q2@VVXNpQX3DO<$< zL>>O`f*pb9x9 zFZ+*nr^9skF9bUTPyRu>`vu=2I4HRCN9|rCc+gK8hXubcxGoa@XYFpEqSKqdUE{i` z8s8weLGbKfw7YGZb|3Vs#ty*`33dt&G-~$(!CAja{DR*V9L&-2UARNLhXwBitK#QL zny%d+5NsEGilNwpUBRIfwErWFZ!Nan(d#&KB1=k7QB)DGiUgNcY$H_XqrGj08w+Idj9y&q$4+)+lxL)uQ z!8W&!uU4>Auw|miFZfNtVZpaf((d(w*ZoD~f&v}i83#-Hf{#B$F~=0I|TnG*f03PnG&DivZEwE!C844 zhXoIqrE#6$9fIoxzvR;HaY(S^1dR(8>iAw3>_0{0K_`lT z!RHGO7i;&eg6jqMJW2bf678NV*f01J!6Csf39c3VgW!6>2cN9tvz6-j&J*kue1~Aa z;9mvT3O>#);mdUR%LF?FKO{IP_(#Fy*Z#8#ba;p0xq=G>p9zdEpF)DyMDQXV{!YOK zOEi8?!q*8t$Rqmtn|420utV?zf?a}7nWz2R&(Qui33i;R@u))W?h;%jI4F2@k#=to ze6wK3SvvgjUI{O_$9#?bf@cb@5q!1aI>Da{rlmT*@e6c#hv3D6U4kDF>=$fVsQuH~ zI{X=e{mV6;;M4A5!OsY;7ktVo+Pz?f_J4=qpx|kziu-xmy+&|Quu-htZ5L|yBEe3< zmkJIFo>HRy*9iVfaIN4gOSOB0U~`$of02&AP_RRASg=cQqu?6B$N6>mTEVvpwuN+j zLr>H04#8Inb_)Jfa8U4m{~vp20@zqp{r|8Eh*EY`(4wq@kaV32LT3rknKBdGK@ib2 zP1Bh`nua9p%&P`CG(( z4!i*zx?24ICAb%S`g!7h2>fnv3H(R!6!`k{#eEq(a)EFKeBy<|E$@-=cD_is75ppk zH2Aj{!$0s3OTu&DyWWWJuR(slNjMC?>CM7J;A<`sE`d+JRCpS^&s&6Nz}sCWJO}pdD@c+QQ;I(g;?_=QTRl>92ac~9vRdCDu#s8h(A?|y@Zv?ko zC-(Pi_F&q;R`c^A@WtQ~_#yBN_=I|Lq1TB09QZtN z%d~t?YIVxLR&d9Ag~Q-$z`fv~fI}aa?+?Bf--9m($H3nMmp&ry4}G7wp9Wt7o&i4! zo&&FXzqlXzsC<7txCB1xI0U*5B%6&`2G&@?^j2HZwU{9kGn@W2R`Ut;VE$F+rl&8Iq)p_o8J-p3i!tF3WvTZ@wxgw;T(AM ze%Rk7_Q!lrxD~wj_l0BNH-byxC%`k{2WG{61$@^Jgj>D@|9>bP2LBG+3%>0~Vn3wu zkA-J6egNNpRs4I^Pv9Q>P4G1MgrAE2Ecgy^s4U;V;X(KZ-sxw;IdB?04gLmr7QD~T z#eL{*@oxlN0^bLo0`L8hxG#gx1W$iWzCZI}v7ZAk`-O1p*TsInUkdkvZvf}O-*`mq zr@@tqaOfNI{lKq;!{EEXL*UmvD)wdYU%_+WJ$@tht=|;?Uh!Mu5_lRs1K#a1*ndmh zXTh!a2;UFx1t0c1aX$opGk6O85V!)4JTC5Y_lbXR15bhf1aAGl*suG&xS#uh@MpkN zKNkKGxC}n*58^)bfY@IG4uenoBmDcR*xw6oc~JO-KZ$+$=fV$xLk|h}{8{WjRqUt0_km}@2mej% z=fF8|>m%adSHUsx{!fbgY4A1R3V6G}BR&=R{te(E@JGNU@NdD>;5Gk{@5|sngXh2- z|0(w2Uy1*>fMehn{!8p1J8oX;C-GF_Z9FkxaHUK z{dd46@Gbul_jBOKz`ef__dQP|{NDWZzuL;@Xg=~c>C?eehxeYZh2h7 zyA#|B-hT&i-wVDBJOutPcow{6NB9r^3Apw5;{TaDiG3J+BX}CTVb zzj{}3KlESW>%qM{Z5P@uM1OWe{B{;jg6F{ZX#5J#1&@K}z~2J5>?;1hhb!1sc4;C=Q$ z{J`%3hjy3m{{?OV=Uc>m416Cr_dIcb^q%k!TmsKLU+f+PZ*kwUm$-iiI1K&^cnaLN58Ur9?r#Ez!T$xvz-R4?_<+9-E`j&mPwZp+h<_J= zOW?is7yB|e3$B3g1BdpN@7oU$_r2f`f``EW1((1hFA(?B;IDzp;GeT1I4~&fBF9H;4t{egYZ505^(DQ;{I>oF!t7-~ z^+Iv~S8(Y?!tZYt`!cxgVBtCNZQ!8;#r;Vy75ftS3*gW}Vn6UQu@8g449hYk_@SG+>phrt`cIdB;~3vM|^+~*FJ@2>_=gUjF<@bY8D{Ve$1 z;M`&I{cpf!@Uk%CbGX>w4UU0(B4S?xUjUu~KLVZuKc@};9U=am3LXOA3!Vc%32r%3 z+^=oN_uw1BG4PHZVxI$dgG=DE!BgPt!PDShgJ;3Vc8Y&<;ETYqmrHyq;Mt>ukL!Ya z@Xg@Xqs9Iw;4nDcE$&0F5c^BOt>CA?z2H-piTfD%PK}R|@B4eiz6Aa-xb;}E-{F;F z-wS>{cnEwOcozH&I24xeUw52*-vYiJTmtWRyx7lx^WX}2=U0h+Yef7z6C4A-1v~`) z9JmDjBX|b9-wEPhs7?I465I>E16%?>1#WE@_s5+m-{-&=fJO#c5JOlnMxB`CBO8LH}OZ*=P$H2FM zr@(&!&w>wJh3~uN`+o2c_#@yM@FU;~_`s-qA6h2guLZY&OW;=U=fGj`f53C#p_9bF z)*kWi4sh(1!Uvr!_EX@?z|-Jo!L!GS`|K%5-|@mf22X)k_KE#0xD4)nmAHTLYOybY zzX6^G@480p%isbybb@^U1#m0)Sz;O*hGO9T`oU3ge=N9lweTA7^lODTf`?uwdpt#S0Zw8mazXcCnChq&!BmUs?!J*5= z{w89UmtOGQ8oxvAe-3WBTKMnyehPf%Y2tqwd?h&c9&!H_a1MOPYsCHBd&PbTTz;SM z&EW8L!oLGgO$#4zx_lq|w(v^u)OUrm;L7)f9|6hkq`- zd< zZxH*T--!Dwz%9QO-XSjbt>95`FZdVW9JqH#+)sf&4xRfP29! zhsAvi`~`66cjA7JB;p4?8=M3G3_Jynjfnec@a^C-_|TNtSHM?+=fGbDw>&Q4{{b8Z zA36&E!E3-}@FchbegNG1d-3n64f1_2_?_S!_%ZM___&SYzLnOox&GV(j)8mAVm}1F z0bKs0xbHYy>_dMN{t&noeB?QZ4|ozh1bzfO3x0J*+|Pmk4G#ZV{D1wJ*vG)%2Dki0 z>|c=;`!M)T;28LC;2ikuadBS)e+4`XK01f^fUgFJo{;c%JXh?8z&UUUTme_W{dsX8 znv?G@0uO;70Z)NnQ4sgj;H$tD@GLm=SMe`W6!)#*)4;vp_kd&Id%&~c=T6A?ypGTE za0a*po&ryU9|q5Y_nDOM=fG>htxt-7H-me@zXA_|ci)8Y!KZ;+|1RH`z+v!=<{tca z@DzB(X7O(td?C0Dz8hQtZ?^^E|69UKgJ+%={vkN_jBw|9;=cS};j6(F@V~&*{}cQ1 z^Tquv_+juIc+CZ3-}0=u|2jAZKJh}t4}1%F3VirQVm|}E20RO1d9m2{ZnwQE-|N6R z@ISy);E$BV{Ve$4Hwst4Q{dL^#lMr^1pmPw1n0ni2Ty^od^7w9zvvR-@($wPHQ>;W z!hZ(0f-k*P+z)|Y_!jsF-U1HoB;P*)j)6aYnYhn^ce`A88hj484E{4Xw6plP=B?ts z6?`Lj2>dL#1b)NY#C;ijJ9rMf?-gP{^c?ZO1TKM}0GGjMUn%bAz&pHMIJb*@UjR>m ze+`}ipLmtHuYhO3y}QcyN4-PrW8n9L=fF>cdv_D}XH1FvGWgTr3V8c>ihbz0;(id^ z3jP>)2>fGk3B2RGP>b0A5*!A%T`lfo z;LE`|@bADg;MMOD_p{&+gXh4ZYs9`~PYLfe;4t_P;L=`Vf6;rz{T%qe;PBpJU$_?W z+ei3s;3;tSePSQlSL{Cz4uki6zu1?+w}Yp_{{hc}S6qkqfNute_Y?o;z%g*=2gLmp zI1ioy-wB=r{|`L0zxWrs9`OTz0$c{~@XgJ={LZ?gT?&|Zp8QC7tJ4_*(R2JiJ*d=H)l_Z}wS@Ax^fFM+=XE`v+Aihb+h;{NmCA#nclVm}QI-zFS7 zLfj|8ysyITZR_m_5Bv*o1$^)wVxK!w+)sc@;2(jfUM}|g-zo0rz^?|+9wqkg0OyVt zz6U&YjPTRo8Sn{T5dUVu7lJF`uYr4ymG5`>qPQOdp8_s}-wN&xi~Ct{3B2oF^8GZp z6I=$L2d;p>4W0vU_a*s$CL;c?1y{iLfm_?e{`p@P_r2f&@DTVz;A!yRz-913Uy<)y z+Qq+Na2Whqa18tpa1Olkt4J^SDsUP6FgVm9{vTcz_pRU?z*FF#g3I7t?iTkI@Ri`! zPVw)4a2ee4HF4kDCHA{~9pNn#z62cV5#IM3a1VYDI0p`W6XAomfJ3j8?|%p`fd{`O z?q|TC0MCIR1-Be0-><$0;e$)y9QbzdG82ESK9Juq_^8GaU z&EN|7=iruCiGRC(2k`^H3Oob85IhUM8yq@8zTe}!@_iV5K6nOP2G4?bx=-BCfd|1e zz2e_(;0k#6`^A0Ba!{D!jhrkDXPuy3)o53wBV;48qpoG$765SZ72 zIlZ@nj{x5TUIu;$dH99Y1N;bh75GW;dhkv^l=Mu4_XpnzemVH>;8%fne655R1MdS) zf)4>tf{zEk6?_Kx1K=X~7Vs4KYv6By9{~Rt{5beG;Ag;p2e`+%2$ z4*~asJHSKWRp27{4DjXPjo=S}H-l%umxI3nz83r-_)FkFf$sx{ek}2S7`zYoPv9fK zq1Q?Jjt94ZW8hZs2)F~h8N3R7C3rn}8ax92Jh%wH7kml$Vem9~4tytg#|I=mv)}{3 zkAsf}ht87p^nwonuLmCu-UvP(d;z#0JOw@r{4sC_d^`9~@V($!@I&AV_%Gl&@OD3u z^n_k7@!bd90zMpkC-^wU*Mk25z5)C{@SWhjekSR=7kn7_LGUv0Aqh#}YVh&k*Ms}PIq+HF zH-j_aYrq$PZv;<)zXYBJe;@qsVF~|H@GeQ=e}E4F@A`8|&k^8*z{i6l;C^rvd=~h% z;0$;Sd;$24;48uJ0Z)T(1kZrK3@(Fz0G81)c*x?;%M~XhhO`Ft`QW2|fhe z2kr;I9()$~TyO?_Dfj~L`@mO%KMno>_-^p0zz=}S;NOEE2mcrRZ}6TEOL}%mNqPJPrOPcn174a2fn(@GN+{Ur78b;C;b! z;3L7IQAyvcn0F3^X0pO@a2b5I#^YkY1suu=UkWaP-=(<+e^7IOuDHJ$+zP$}JPp2| zdDl>=^j2|y$S;YX8w%}G7Cs3~m*A`ZAPrsyz5*Nre+Ik}JPR&?p9EhE-uDp+Zw9;! zd@nc(z7ISIo&~4D4}#weu7IxwKMwvR_)p+(g6F`Gg8vPE5*)f)(!Xy7`2#){+yZ_z z_z3X!G)LHjI?~Fd?3e8go&z5O9@-@KUEmz}6z~k(zYZLNeHJ`BA>UsLo`U`Rz@?(t z&w!`l{vL4dT(SQPxO}EC&n-Fr(>Y;Mt5ZBw5MBq)jSHU#4(EkGt}*nzz5|XSyq|(g z@SoH)B){VFeLrO&hhIke&jhz3eI)kEeirr@Ywn@1H3goAzSk$gz4-nsic6uH*GqU$ zf_uS7?7;q)LPH~B|9Wui8-?!&hu$Q-7tO8NeFeM)94d+ZP2k-7g%8?E+|Phh;5qR3 z!C~+Y)OINU5&k5&jPSk!o`ycy5zi6#A-F#a9KKk>|2{Ye-hUTyKMj5(I0WX$R#kp{ zPri>(+rgasr|=B80{iWDL-_v^`_sTf-xt0YT!Q@x)b^7#l4mFUf{1AROIQJ28KL(D0KL(!tmDumUk9flwQQ02y#+j#5WbU{ z(icK}9|nIE=?%S5>?^Q81YCywDa=$}L#Y4f!#)T5X=P9S@6{6C{oq#cf50=SZwI_c z(lZ6_0=IzIYxa<*yk@_f_f`Gq{SSh}DDP*$A@ECI%Knu? zq4UN4$>3h_IpFenV*gIXRA1jF;XMs5Um^UCmr49)E*Jg}c>0aPBQ${H`X0VS_($ND z%Y;ulRP1Ay3jZ2hhWpbF6Zfd z9-Lb)?a$sv@b{(A6w=?LnA$U~y@!1X?a>|JFxsQtkHq(A&(?r@za!yYp)vZ??}A&v zyT4rG->bFn;Mh;(`?rASeu?;lrydsOd;U4UOBLal93?#cknoj?NnRci{s*`P@sA%Z z@t=YHcfj;|T8O+2b-zOFV?P)EAb9Q~;d>Q_LM;ynzw8)spF{lCf@9zd6;piCKHdQP z-uvYH!;h8kD`?L@37$Sv%5yl3`1A*sT-+bf0sp`~;L_3Z{Sdeez6>1xfP8-oc$(@3=kEjH*jd7%PVs+; z+9|d_6+CmG@CP(|YNy%$kKn0@gul8=zMmqYVEdcEtv?j^J9WeV?+d>H9D7jsE^zrF z;ft2R{R6@ef@hAF{CP2z1J|Ef=xbjCo`b&c^Ij?T;U^?M?*PZ17T)JL_#YMje*&%? zFMJvOt^B9oIX$PpN;o$v+?0J$uTfn7Hiv45Y@?K&;aFV#MER+2B z894T0ao>Bg*iSzy{0VSnPjSEhDPrGypV+@0Jbj$lZ{H{OA!?^N{bz&2j|u+(Jom8h zDXYbOOGWt0;JGKozune|{ZLrqe+IY(_2m}LzE|vb?HBiDoR{1T4ntnQ1@5JM=lJb> zD#E9HXFeHRrgnz;(6wS;StooL{muDZ{<3gaOt`dB_`To?$pL@=Yw+A*!WX<++)qG+E!c%V+ei%Hohww`W5#GJRo57WD3V#h8hW(!F#r-Vef68gXL!IJ&`D=tj)NXP3 znbW~-!oz0>&m1lM+1Cn}Nlw`P1=KEb`sa`z_rFfKMEtZva!gm^-Q6 zRP~GUmHC51!sQLZZ%zo$+#>u5s%OeQ^82ZzaQL%gpG^tJJ|}$DsBq;=!ViIZ-0I_e)2@kzg;`4X#-1CH2pDXs|9^t=$ z=Uy)S>O8&&-wp0<5&Po{Vjp`-;(IALx4YQSf?JM~`0QR3_fsbd4}wGBPlAVDA@(~@ zi2GUe_nqMBBgK9cTt<8TU2qBQdHW>3r*@d-=`oE-PMB}qB=(g%guk*`IP_KF_iYg_ zA%Fh>j@=;kuRKreTlbOpycL{7|NRSawIyaJ6`hVDsUL>>Eqz3Uy1wP3&j02 z+OzY(Q)tib0Ef^X{0BUP@yc-*%J(y{{|tC)CkcO-i^zW0P-r98m)pU)w@G?pic6sq z_-gPJ_!jUq_z%oGQ^sO`x9`Qm+ZDyXHpSFFVtsoOd<5*@2|fXQA2Y@86!`xya4X`w zPl@ceYoP!ozm8B$>r1-}AH%#`D70f)!haPr*`0#*-<9BA@EW)e!To8lkHP*d@EPC{ zVv?inL-33?e6fu&@6p4%+h+g#H(C9At&Kl! zq6m@zplI*~ZVg%o^SSic5O_9b>bP+Bj+Bvu*rN8{cK)A1F4$`bX8)t-d|0itrSJ>>Yw=w4Z`uBI)?7wN_SsVY{#uXbs zZsR!{KV{?4Tdn!EvyGo`<9%#=pp6f)@zFN!wDGHKe3FgV+IZ!2LZPR23Wfed=4mp| zkohl}|B-o?OlW6H51H-B@ZQFbWOgF6Gnwa**@eumWOgI-Tr#_pc^(6yqL^O$Q(lEP%?*;Sw^OZ%qz(pN9IH_y=2yr ziIF*tOo2?1%mf+UbJ;{@Gnu!Lxs1%^WZp*R3Nlxcc{`b_$h?EhHDumP=2|lEBlCVT z*O9rN%m>L#lld^2kC6E&nU9hAIGHHr-6!bpPm;NT%#CDDqTfy?(?@1CnKfi?qTg>O z^C>c)Ci59Gw~(13^I0;VBXcX6&yzWo+^;3Gj!cZqtH}(I86>lw%xPp^L*{fcXOMX< znKQ|}jtuV|-9~=gPUa3Wcar%6nJ<#Li_DkEe3=aIL4B1>natf}zDDNjWWGV>n`FL4 z<{mQllKD27?~wT}nfu7xPv(1MzE5VB%n!)?kj#(B{FuxGWPU>Cr(_-^^D{C(C-V@Q zhspec%rD72LZ(9IS7aU~^J_A{A@f@@kCFKuna9cep3EP~{E5t;$^3=P6J+Md{FTh# z$UI5r?_~Z#=AUH#MdsgRo+9%fGEb9vhRlD-{Ey7DWI~izLu9rivpty|$m~dFCo(&e zc@CLf$m~jHH!{y9vpbpRk$FCuJ;=0>*^|s(WcDVr51D<*>_=vQG6#@(0ht$)Nst*P z^CB__k~xUXi^;r%Oe>j#$-I=z%g7u;=1?++kvW_U?-3qJ=H+CPWR4-zxJc~?Z+vUujV$SpZNdUk;dAQ*Ha$8fy^JM{>SO> z|7%zLwJX$GmLim2ZDiWXjFQ<%CQT+ork-|ZGr8xs=R7j!levJ*g=Cu17V!|aH58AZ z83}LMvLRKBXHwY>lja|asm(?CAtEkDQo|E)LcbK~8}&5|=iEMm$OEFc5tx1llkLl-3YBPCPDCWnv$k!dZ(}~g1R6Yi$`p@Jvo!vlQ zC?7h>^=M|IurWR?&LjMb{5xJKCWBdJWvuy^)n z*_JK2@tnnfiFFToP}r0%CO5{5<60Qbevs3g5n+jB%+V<&g|cU0ZC7F>Jzi+*8c7us z=}gb^!S$>1>B&?+%4wshkLFXUn2JaDmMw`)W?b@Y*;wM7RJ?EP`hhiT2aE0TcqGy` zoG7G|6ej0kUvljr{g&LA$j6KMM7mh$OGcygTaWT1Q5?_n578)nZ;iq-3L;TVk7rd3 zC{tLF(peP+A};-OHl}4U$C47wZpJ4>vU28IWgE;Ic>^mt9k+DV@+fIUci)&}*b{;aJ#BoBzS89Hz7SX4+p!N5XpL_rwPfZJIKaL zBi%@p)2m7L{RzUBEhDMX4dXQURAVxiE-a!(NXrKY`%bQ7h!iPo85{oc)PLRj(Qy80_$>ab6yDCNrr-KI+w2 zRDZsV!dEkez!5O{;3o#E4Ep0M29~en;kM6lY8yU_Egy*1QFij#K(NpT;(!{QhDm!UfUQ7&UQnl04sbbi-D!O)k z-${MZ1&m{-z79bv7?Y`tXGZdx01XS`BWYTM$dAOMSUzyc_b$V4nklCeW6=RE@7rYp zJubiV4BA1Kqh1YQH?=j%bK+<-c`~>%60I@waQr5*&e9aKPj!du)lxbH+7=+9ZPCUf z>Rt0_(LS+vrg5>@tTaK=kQqL>2zvsJF8k-_nEILNb39B%nhiA#C57w8Lu|8 zQ&j~u2#8cmo7UcG1Gd5TxP5VQ0Vlc`=*X*MT)O(Bvv& z8oSnLF!it70)36qfJgnHMn;#JOOrwR9LFgx?;%?xL%IQ<1oU6-GLJ$om85k8u>HrO6Mt3eeFqNxS+H#wj+ z_vFSDjVe6EjojpF%@4^Ew2QNLd?XbKt9_B2np-;wuP;etAuf-5P0Rdhy5=C!M&xBrNFtBHwAQh+U)IGX zo9~02s-Lgvzm{Zeu&&MZ_1&%}B&3Z?p)fI=+MLVRD2A?dmUg9d*YRvLM*WZ4?y^a& zo=sicBMhtgfdrvG@k+Rwt7Ip}j5v7(&?Um=DLy^yCXq=eypuuzYoo0%BPy12@X7t*}t-;o%h1r*vnc4(EBX^y;t)7*Fl zXY}xquqbYDXE`6jI!_@rB)IbwCnp&*2bCEgKW8Err*3qfGrH3VN!wItY^B&i7EK8w z<&}{*f=p$L`NoGj&dtGm2iYu{q8hIiH0kMB#$?SL{2AGSrJ#A}YK$;=XhUOa$7axQ z)tyfj#xs+tXpE-@S|{u@-jt|7;hVnq z6#*$yY=L;jmGwJ$g9WP)mUT9-Jz|%vW*b-Y)3|p=k!$mkbX={ClUQN-&r@(% z@iU(qnMkIzpk!R*9I-ZbZV4-q-!L&oeG09n$?~EeDm5^s#YUG*@CvM1>$~kK+FSQ3 zy=Dc}QAnScT9A-Bhf^EU*@X$Jkf8+^eU02%E}E5tHG#~(d;U&)diE7L%KtIigkx>Ec%<8``W>H4r#AH^X#m3G z4OaP1Wz~*xDo%|kX_|`wL2umnn6s%WFL{OVIfs{Y{!l4)qRi~d?99FOP6$BXe?F|WyT&3IF8 zYT}|VE&3^ssGk&jC9OM7D^^C*ShreBTBo*}wZJJF)R%5a)tjPbthgA*oi@r%F)cBjWY&OTueHjEo^V~?X=+N8zP<5(? zA2FLG=o1l}Uw-0~uzr)E9I}UwM#Og1BN9oSOY^^?=l*C^Y{X35D8I#89%q>DKG|%hsMqCnkMfx}Z5r^{o+;Ilrj9jeterh~$Z<7L zXy@ZJRNT@7_rd(#=5mql_~>|k6KmG#pP7aRlNcHdo)oA5f@Qp8 z66(nLgv|qPC2PxEm)Yiq@|wGfAXhJw>hVCdC|GIo*&j5HF7t+(V$Q^VCe z10&!r4tR_ts%!p&?a`~V5pHLEb<~t()A0t>#HJ?PB?c_djYWb_P0FY?o~2z0RcnF_ zZAmfDX=odx*g44y$zDe;kegAh3O!!1gu0ovgd=HIlTN0?Y+T0!-4;7RjYk$<(HFL9IGrDo~^)AeNSa z!BcteFTjE#t&=MJZ9v@p<BAd$7zjAbC zhBhOkB{^dh*AeHMM+7Dls1l^ctGnLDE9MoBgQ#?Ctyp(m zBLvT2oMfd-HD`3#Uz#(OuKJs^Ai+|NZY)q<BKA+yOF^C6kwECkwI48Bmw8P1F zJkcb+d7GY5iYRO6Q!u&&^3YjZ7NV_BwQyX$qf1M)yjWYH8yw;j+2mwCHQKjc=K0vb z9pDW*?BNbZ&236Osq;IzFz*1!S%2%6oy+P)tqh)1(k$`F%4P=2i9X_N2#SZ&UaJ|jQ+E%`wkCb@|sX?rE|bYhEU3kBXo%hJ6& zj#tW&k_A@;+u8Z`ak^TES_kS;cphQi?BT5iRiB0vnFM(oPmFRXa-ODU&89kF+GLCWn>{t0Fe96~>4= zU)IA4Fx(<(tpzP2_qaw`EwE6O*EBQACJ|RE8peW9w`oC$VyQ(;WjM0mB?&7f38XqT zV9nnS+Ct0(6G&4jb*k-Q_uWjZK!^;mVhXFAtAkw01fB6u>&l)oJ_zC~DdN)2lf2C+ znqR?vGVPmD$84DeFLG@i>PtsSV?9pIO(G+@Jp&#cJrz!ywo{|lGK~F68eFOmHEXqz zLqGD;el$ZZma^?cJ4B)+TRnr+CPoKW(}2b@g4njQ%`5FoE8$cw`WluLpsY1&O`twt z;)XpEp2((I7ld@d)X2>)8@x2lBBhP?SY||(os<^TZI~;l>7q3{^@m6A=Eif8%Lqje z=T%j*5=B-OjYq0#fJb$sT0`}N{xh|oi#yfrq~3yS`{El}6$%o-<9Jf-R_cT95_6L3 zPW3F(bsyZ?7M34sT82f6H0i2tmu5N#iGC9~$#3LbTNc0#-rLhX$Iws@P$P`B=hb7fn}5~}B( z9hW}Q_0e&Wkk#zCSV4Dy@{j-2(Qz$qxoT3Ec50mV9=Cypt9EDC&1=2XAZf!Rvy`oN z>+D?GFn^sLwRM9*I=e+JcwXJ0RL1$1CeuWF!L;)0>=xZx@z?^j;#(t&99ng2ZIi`1 zA8mTnXPZ8_kZt-R$7EbFdL4;AJll4v&gZG|`FgJr&cNykz z)@rL9#uWbl?>zS!!HD3QM=;vKIO`Uk$7u-4a?>sf7R?>bqgYM=>6--&1;gvX`hlHz zAv3;-?%*wMl(pnZ+lpON62{Ag#$0ZkZda7!P5K7WYRQ1fs(Dv)f~P@8VG|vbrAL(F z$#gzBk)ijV#lk>FcANJ3h?G(%Rt3r{%maZQkK* zLgbniw;tXG3>-JN`lK{IXxG!FM)@g|+7$jj zdB3OY3i(JEpTg5Mb?M&zJ`xSpt7+XCZKkW|-FPFqhg3gOdETt2F)wsK^b>kYP8&{? zlVr|cnrIK(Gfhgq9n$2gZ`V-o)UdB~;F1*yn$YOb+R6&Yid|P6Jt{cI)1`vf7evh- zQf*U{yt-EO`ogQf!h3Xybp_o;7hLcyIZo|uT^>}|!zTOZ&pX#{uz?n_ zZa?(_M~$Yoevkb%tsdtkoJyY#^iYhI?su)yuis~X{wAD?ht4z9ZpK``+P!1+K8n3l_xi+Du!fPBniTPvIbP$r^W+Ld_~b3SZ+tg)UAx zg<~7zsm-b61iebgS2d>cA-Y{Joejn5uEkM$hn_SYhbJ~L%8z{a78BnrpB?9a(F!B~ z#cwW=f2U1 z@JyukGD20P=p(L^E;o{gtJ@v*%8Y(hkle&IVM=S185gy!ZS>is zbQyk`C))u%lkLvvSTkZ~QolEMD8XVz0;76<$XoFIYKmYb2CHLZJNDyPe9?9~PZYJ} zhOf^$M>G5+pZP$9{g{z+c=T)zKLo(JM0{*ENIiqedVFLZ4q<+~~Qok_mMm6|ZUy%mROm2C;u8{u}6JAUDbnzUiM0x&`C zKCeipsTZN^wTm0`? zST>f<(&mvWlJ$MmW?T9Rj+y$^+H+|?J2&HEtIBKrYu555ipkBJ6T|7r2p_~uW@uwf z-MUH5@aVY8f19&5`lOI{ap@GrkxWb_AiIeRJWc`d(^L5(_1_$Lf^Ko-j+Hw1)aGO= z$1l0)Hq>FKxyM%S)YaN_`)@J1QTvHczgT`4<-@jB{-B_>uT-fssGgYrv0?M(INje{ z7|+s`l0`Zx8|Gi-qW9#+bEvyd^DCaFUp7q8rGoMkiBdj?f2OnAzes%PpX#RAbgn+)@eiRPpB4rIZPOd3&(l5EofN_uICMC3ebJ?K5(qFQRANLp_A zXhM$Yt(jG$pn5G*cPQn%;Q6yk7Y$1*s%1gd^wF`;v(AwGAG$UQr*B|+SDfz9T^@(< z(B|$sI>bx0QoBoaD@3Vt@kOa)@kOa^@kNQc#l;{@j+J{}s}$8l?=#IfmTlBLmu8W+ zJg8Z;T%{>()1rvJORME?fSxI6y{z zRCTVpLyW5BmR2g}U~@Wu?*!<9T4QI*5baqibFURVPR5EGb;Oi5W1*_y!}~6hf@f7+ z*Vri%I7m;zL10>Ul~r~+%Vezb@YJ}`+A*Jb(54H#d2&drD|{1%TJN@Ptv0177wUM3 ztsu6UWNCG*_G>3gs<^0p_*s-~S|nLjLC(7KjL$Kt`cZ!$7dtI*`D!=+&}9XB)Cc6^ zCSEqkZlEc9CKK0}H%x={$X2=c*wl8`eH(BjY$*AfQcJg>4xVCBaZ}4H^y(46BSep0 zsg9WYVNJnbzsSS$8Ut%z!rxoYUhoeA+hXb}W#(nd4fWuS(VNn(0;@IMYI05qq-nbR z;mbGq4=q2^^4f@=6Xp&>l&mZ{5U2ZH$G8VEb&$0&oDk)l! zaZH*vq-#n|vyEX`)kMp6zJN%s5#!9Z^;}yi5?VhaV>xaAP)VX6T_tnTYXWG99BK1d z62A;0XG{7*g=$SJSGD3qE<@T##af&;*6tPK4wyhQGUdSm5dD`s7kL{X3+BV57U~VKJgG)G|~=#!|ZRs5^xH@ zZxogClgm`1K0oY3acyu{*C7~M=uc#`>M}~&I?tqvDaS^Q^>XE*)sbOZDyL_t;`&&G zh23w=(KRTgK~rDv_j8qbYHuQyFa{Lnj>XTYL2DuO+r3>nZo1l=B+9%sRc}1i8oVt- zgA~&;?S8f<_|;CM1ii?qgD$2wOpH&c!x?g`x*i5?0Fr)>{HF>lNYpz<62*k>r4&^l ze^?{k=8vgrkMmu2Jf6~=uvFR$I!0FoS}&5Tr>^jrg&$zkFVnIek&DJip~ocD)^Ut2 zF51~eExL7m>?p4sx>;8F@}Nw5m|ni32rEIPeKjMvNz21%e2`~k+~hF6k+w&vH#6tD zI)gqLn;ct}v)mchMrZR762E-OPhyf!=C-77HD9#BD)W{PoyNgD#xD(cCosG3A=Bdceu zL7+`t9SbVbksIgJwR!ERpPJv+H|wQ`Rdr9s^-%aIu(^wJs#h!<^@U|^d73F(&6!~b zY6I%e20v{?GgiT^Gl3wt&)TPg0j|Y$m^TD{d)4lh{Rq3elDk##M73QWU)3evGU#p0 zXMQ8r+22}AaITvk)Y&_>ed-xWN{?lrLgT8SSZu?~dZs_q8EK;oqSYHqlhvSqBS!ozveBToIs3@P7<30Mv<~y261pPj z3L7jkC!Z1D#$=&Wy~*obNgDIHhcC=_^1V4Z(n(kR6!mu)EQ&e&?nEO3Y~J{%X`Vftp7SUQbA#;mQnyXQ0*cN*MF^jydGV}82n z2J08kDb?+{c>h|dVd|y9k1(6&zw;3mO_S@mrNuNcaL;YWeu^7xOCQCHPPQGJI?A&N z(^dBb)R?w5rTuI2P)4c3>T+Z4uCP==YY4ax#8z!QGQw@lL63LP{J>J4jWyaX!;a=O z*=~z{O({rjn9McUJoIaF{jCua&qJK=T4Ie~b34LYE7j|J?xSZ?OQwZB%Zp>?mcU(r z99nfti{{T4mj=Z)=yhmNV(v+@)&Xh*DT|uXsJQ1vjaH>Oq8?~@tiD`w>`D=P*S^%F zBz*OpVDLtgPQwOO0CrSO}n?GDnVId`8pbP`Ce05 zuqukyr3!2Ktb%qtJYw^{N=sIbDn>*AYdYpbxPx#k{quq!yD$>%qJK@**M2O;`C$ov z=XUH`MYKigc9@3?-}Ee*(ws3GoG9I#ViIDSjk@WO+KORWbhA>OqSImPu-`->wL4$W z!&Q>H8G2t0H~#Q2K9Q&E=jd4-rCx&=@;zZHhBlEUN7N>XSQsld4(ESx7`rYxc8PS< zaj}njt$7aCbtQ0d7mjVE&bho7M!NMrWob#bYR4emm}j{3y7Rq*;;XK&aIWjn|1l40 zxJJ{~v!$bQNEy%Nn<_S}>hDsyjYiREa?DXqQ)}%!TN zCon3idr#n6UyNM!hd4mfOmxW4u#(U)b{^T@J$HWUmbO8%d4YH`zBQHIJ&0(YH+2@ z+P9VfIm}TJmBl^2T&nS|Ijr|zGyKVCyUW8wkmkQSi0DynfPWN2IM zRU*-;Tt?DTF79g1^8oCI$g5iVOwywhp*2Q_-a->^>MQ75tSj=e zC2#+kCQqzr!JU?_hsHHU8!K3Tq$#e_}L8D&DTMwPxB-t(of-^=)D%GkTP09@oxy6I#!oZ2g+$q7J^eYna=% zr@AnBu@twunbmR~@76Evu`yjB%{_icmTo!MY*@jk*)a_=I8^)V)~5=2%uFYcb2*xR z(Y2}c2Bbc0T~C8DJOIa!=XCJMHA??d&79^+Qx#gg8K@RHXJRS;u|&3-&*A82L6GiEJS;YM(aaV|=R=WP_|uxbzVmeaA6PeVS<$JJ(C_ zx)URl33^0T&wmQD*{xcDAwVWW!ZbNxml%#2txrz!o$#dauf4;pMLuf2y__;`ai&cY zrdsQ&(Fr{*S3Nr6BIz1VkEHXdBwu*Xs>euE9vDN39Zl^)@>P6#Chvr0E zjMQ!i@UFXRebX)+Mst$RY7*h?jlDTp+|`(y{~Gr^`nlW4y5Y!T7^KDWRF8=+tGZ2Q z!1ji(&lOjWo+i?2gLHo4YuX;-hz^@-)Dl<{HDa$RZpCPUk8_FydL+fK>v9JsEBe%y zkdB&cJjChJO>)5Z@Z{r#QF=avl%Dx@%QJXR#hvSh@$r#(p4M6DILN4Ju7p)BZQ0z% zwW7Y1uG$?3D^ce=Lapm5OQ4)``b68RZ5lR8LyaJsBJggVZlDd1NQ5V(kQA+LwI*T- zD?SFDdd!C!ooBnM>pnToH>6I^N2EMt$)TxNr)cTjH(JI}Z|Cr9N>vZUX+mUPi{g1H zZV9XEKX4Zr#@h>?NSdKoE;_TwK95T6x0}&Zcv=$sR*%tMOU!g`Iu~CXZW<*F&`u98ggR^hE~Nw+h3=6cS9Qq+DJEUR(pabK|fn> zp<9YB=TVrbzH28$Y5&-iCK@$XC8@4sZqCb8a;C1??`5r2XPGR%2ATso$JuLXOcvZ}_vbWGJr{~n(y!RKgY7s7$MP0{Ri+Hlg@ikwa zwa~M3$B1!ZnHYLK;P7mb3b9>H1)qKi&0=&|VF)OC!Ap?JFTpEvfmu9AB_59#`$Vt^EOnxRq|yCSuz6|=^>@Ae$KModbLKbgiYvbo z6eR0S8@bjMUWYvZk39>&QJnwg+o%uj&9_&za2|SdZyRuNfxpz`SgB$1GjYCz%c*~I zs49E~)=AY{@J_o%-Tsq8k5y_=G z^4s=ORCADC#~H1KuMo5)NZMc-(>%)MV4!LqAa!!KMV%y6XAl<0ty_LGFWAW4u_wds zl{T@jeIJ+KI93n5d~_s^EuLP$`baBy0ZVe1YSY6*sroPTqWt4wm{!EbcyqmxlQ>vPKN7!OY zStGZH&38K7TLkm4(z2*rpZ>_gCqS?N);q{fQFo9Odp>o@!_qbgxczWhhoK~3b+gn2I*F4s8or8-%SPc>W)-SeLq6G*2d`~ zrLCCIrmb=;386G?WpZz#6{}u0v`|qsigMa$S_)f*K~LQ|58ODr7S|3T6<)22=>o^u zd}M`oa@3BGxdpZj78}SMKV6a6v0G_nGWzu^eMyc?wQgh80_m{2SKn5q>fWjK5n2GE znqW*Q(tnhjpD8cC+Z3f1?6;P zQuEL$0#3Of_3|W8rRo?-6caAV^dBn+Peh#B$4u9Z(G4F1Yv?*Lde{f|{%YwD6m^;w z@{NY$*$po759BL1<$RA1`|EU@NkdU)O&9jOuyLF&=PRVo)2|eSPKoBbgHlQ0rhyWq zJyY(um4Yxmbv*)QB?9(!!jtCAbXQ?wWQ0y57PRv0TSJA3fJ)Ww40_V;g_USzfbWmm5qQzLj(Nle145;HU z7b_}o<>sM{^Rro|J#r&mntFPSw$C}csp8aqJ?SYlcbSLlN#{AkoNq9-O&{yM2Xvm} zTvs7C>u%G#5&d3Z|77bWv=cPGbb=7IYPP#|1DMxX)8`0~{Wy?!#nqfPwuY zim3NJsP5f?xu4nk9j!5k+O|4cJzWdj(K@aESI>>O+(|;r&x`tP$IRlh0K*iP3ex9k z>iwvTDyfE`cqG+z)oig8t-ktZ>{!v|st(7XTvOsbhBZrFGaIe8cwe1D%peM>=~!m-hCPtsy( zE*fhTC4H`gjKz{jUv1)2UW0PE8*oV<00YDQBr!CBb9#2ABOV`1#h{c;sOok;6Qf2&RN9`T>PdHb zuikIUAEpP|Ihsjq(6z~| znqEDUa}+<9)OL)fGZ|ZkY1v*!?7K!2=}bz0ZrO5oRLwXnqnr5)#YE9i6Fl2Fp_|ep z#f`SeV(ieVE4Pw_P^q~jx3fS6uRjSJCA~58JHf%UYmH6q=vdNJ`bGg+= zVqNlP_~B39Y8GQ>euOgKRy>d;BQHE0)eeC&GG&yWIkS5v3aR*LB5Azwz+Gf#QeCm7 zmRMOSSLtwfWyX_T!vo$f*CX>gX;cyjaR_=e2*FujmENjK%Dv*{v9gVWE) z^pM5L{p(gN@23Z2CWhmE@sWI*p0YkBnae2&vZ}c+%Z(S({M<9$<{MkH79wAz#7U1( zRV%W$nMcqnBhqQ7AUIPH1m{vXt_NzqaH5myY4RL;O4%C0?&X8)*V0Qk+;(=3q|Tk7 z$74HKufsGDrXP6i+T75Y+vi4a>!N^*6S+*PZ#7>(OPZaN^g{M{o}_?wzE`KyX$o3( zJ=%3wN^QlvUs~xBV@+rp&kXlvpC;sVdvQGHTpfcobe*ZOTycxdM-fIX?Y24pJ0KzvFkcqZ*FP4Hu5MD!>9xR7;-#fm^+Y{>L?fm?)}UHT1DU?n zt8%3F%vH35Tg@m>Y)yG)i*jTMMA;Cis%){eOneB2WQ#AM!*LraCGC5!=B}!Rb38cR zfPb#{Fl6=dQeVt9hS4YvF45F_Qy$aGK7P|%dwxb6?O7anc<6G@o#*aG03P4FY0jd( zc1;OYkgB|Pxx;0_S|gSi%l_jc?#1laJFe5NC0x)Z(HJcEtsbDBnqNRg1HCF|eFwGi zO=R~m0XKK%7LxDPl0T*h@?#49u}SVc251yPWo^BYULRrjYF+fMU@LS)rbJOS>WDAT zjv&)1QR>2t<>sco8Do!J)z|}a)`US*ZlYjJ11SZVbX&)y`uLUJc%An_GixHa51KJB zZBiHSIylm2bd3#;c;Q!u2t2Z4zts9L53XraGm=iG3Vo}2%+fy=;W{&KLl@RSP>+~U zAch2626Brtu6jYZ#5I#jjH*#zaEa(2wy6Jj2Nbc6uDzS9cGVPm`>!vyq_Z2GS6V1# zrrw(8ovtMq$TPPr4&oW#qNvRrc-HRNQU{yX&?519sl0I>(cJbsDV+os2-+aN#AVuoGq*BWj;m{0<uaqzPf`GSgRI*sk51N8#zwIqhYcTVXji!CzX=5y|F{HnOvC1-UQ#aFsA^230)}f1ksrJJ$Pig2vLpdW+_QyfhrRB2ZZMm&@0d6x>+jC7SA-x%i4sM$z zq{h0|5^`vHxdv$}VvFYWNRvP-Nz`^z*3!O`vHD88v$PORgChB}6kd}wCCpY+drS$_ zpWu~*IaNi|nn)i%Pv(5ia9e3@YCdGM%_Nk%q;2K(Nt3JxsKk2nterwO4_|za<+yFL z=mql+)=ppj;%DVg*ZMXkYnipPHCJJBt}j4SE#_M=+y{^(y<6{fN>h4lO_F)=KsyKK z!GlVV+enR)Q*+|5*ovm!$;tu@c2sHTgB@Ghm}SjZcVW~g_wK^0S}m~z>sNOeLdvgO z_En#Bc3Vr|wgyFxN9r_XG*P>AT_K>lYFbHqGff?YTG*fqbY9*%3|{M4Ht@;- zSGgb4mv~4T=z>XYVau}a7i4Xdb{3N7SbQ;txZZngqHv_wW{V$AqRi(8wMIl!Td))- zG?=uc)wyoQ&B91(cw$3*WLSH`EUEiNVf#&&>>ZM>U2MI1zT7~P^gOCFNv_gRot3(H zm|B_OD}Yrc_^bBRh^tk2e0JMbVWLrui+^oYU&m5o!>RnHG%Hw-=Qkzt zbcmu*NN>;;u~|hx^N{`-d@aWiGa7m6`Z?S)_GmN2!IkmVytYAl0cIV9$pKkX=iuoE zT-jS=Ek;sRAhkxmp+G6>LzZti@42)b&Pgi?>F2VIW=eTE5CL5OxeJTrLNVD zGF~4QQFowMO78Fc24o%)k&?Zss`>Rnbxxg0(mBZ68Z->m>+*<)Vu@^aoR8a4ea)w{ z=jgtg>uQ@h@#!qBY^3S=1L_%!(}F>>A!r`d76kud>rnHn2ZrRGsYR#n#_2KZs158(-8M8 zZbIBm!O%*GN!cSvliEgC927U^$2ZYa64?#Kjqy}IKW=ZUF@mEmM=S4mf}USVB?|g_ z1h=QA_QoOaWe#KbK_^0K&{3chZ~U#pz?;tbbmLVF8g%m^28(djC#*C?)q9R?N}m}; z&D}<%BResc%BPd@OnQu8=Ey`zOJTF##mM?Ua@jMn%e?QGrI|`5Jxs@C{fIiYAqypySkgPuj^?5wMR=ta4e+PTN|`9!vm zp!1LF%rFn~&EB?CCQM{m)tPjH=y@KR&`TpkH}53JbNUg_+7cP#XO7g1DbXlRqiGgS zdTlh_CdG@O-MmXORz)mbR#S3@`Wai!wDrW7Ygw@>MQ2FIw+tk*8&U%)I-Ole`O6T~ zwk`$GL1&yOhcNcj+TW&xW4cSpva!|_&y6;+DiKwU8OhCvMFdZBhq9NrASxxC)F*bsk&NU=rNy}tolp^jpLHl!SI<$KIGF8?^DNQ&5@$T za))=FTvAvSE+tj9?6d}*Ol;{}wLY0CPn#7 zsaIclYpP0Caco8_X1mWv^RljuAh(-$0(oYcVveLTDbvL+=4MJ1U$N_u%F`*0xZ|dS z-;^kIZmI*e&4)l~-~p_|j9VJMpgyWjRu^N-P$-a>%V^~yK^GtB{WW?>2zDSp+i6Oo zkMd}hx0v2AF+Ne?1>a&Koi)8E7h5w)?Tq}VTAN0K^?0B$P%@mhAkk|%x7DsfCQtJ@ z4rg4yq1Meb=%XHkq>^VXd=g1IO1heY$N#kaq{~B$+?iW#r#VzzA$m>#1Ldmgf|=Ho zHXLWi$)7bfcN0ee=584G{&HoRjVwPdEz#e zQkUyabk%SDU3S%0X!?li3N-bL9~DV+&!wHQ(AEH(Q}s;kD5-Lp+MtEH&NY}wR<|W| z@2_f0qQj;cf8XF5b-n8;F4w!#Y=)ajwO~g>0-CTKwCVje^RSO;Erq7j>P{3KG2RA}6XnZmEMr(Fm8^w(RlrmO zZM}KDDzVOkT&(p{{j$BBpl&@=b#MNKvze;Dx+bjSu8St2^Uizs5H}U6y$%ohKz~*sEU8Rg0iBw^R2{ zF6xw-I$=)IR(fI9)DFzk5ZFkkb_69x$IV!-s3WfX#o0A9ldt*WtX3PhrI|$4bO|+j zTS{Z?H(uwdsnVZyFjWUzw^-{GPjy2jjTB^Y5l7s6n|G0GeZ6%CKm zN@FvJ59ZFhY8pKMeHBa1U_bRX)fz@lBlqfst_DUQ;*bRU3Oh=I-x<%X*HQvC*_YiS4#hMe5Q1bS=~x1^H#s; zm2RS?{qxlnWzOzME}crI)Oijmm`ijS%d{uTtLCO@&Qeo3&}Rlwnthwnv6NK~ z^fc8{Ind^ljmO4a;W;8V(tDs4HgGzL!48Y`?XW*;( ze=-$cJIL2o@Pt^ch47f);Vufytu?3GTskU?3+l8ltLU|x#dIN4X=MD?OQn9|wGolE zJz>#DVoK^d)@z+3Rp-~a)aGL!-D5+?rnN{{7vRhu9RSfc(g(Dg`L*puUYa3ABID@H z){lAhkW1IMq`PidIUuVaqPJ-2Z7VYm?iSP8LMmV6^L2E+ylP|tPO&9m-#y&I zK00MDn8g{*D)}*@srRJ8MG5^VWyQQbhf?Kr5Scf|XB1WI>5M=Z4;g!QRsK;k?|L&# zuseBZc*^J2tV3y|2J7ql+DQlVCav5|;-38aywS&h_Ec|sos^!`KH6)q*-7ymEnBZ| zu47@px^LDs)lD69loZuXGvRF`b$W@~Qnz6Jnl|98`MRmmMAw+OE^LQq#9x2maWyqc zJYZEb-2s9DHGHN0Uu_N>V7j}yDbw8r%^O{|Os`*V&Ae$|*RB^jzsOrXN9NT_r38Qw zgWe8hbf}~R;}Fo+8hz`@=c{8p9{gSSMub{&^Fo_;Fvap%?^10@)^JP0Pbw>Qng*JZ z{%x@-S?JuEkH&UkhUI>f#tN^8UpcpCGBuahTM-+S5AHf#^BlXhwa#q0UP(dCdiALU z?)S~dr_A@X^^NfbOEd?jE5)q4AO16vHRMc(9Vojf8uZNB*qC)@%~}J-VKmocTV9DX z&A08TvK%^hzny~O>N6g6H3+4HQ=(N2P2ZkU$kV+bhne_J^+1Q2nwcU8?Li0ifM$m1 zd0jw<<(^-UXG4{$a8D|m7|zfZ%xK>ki9{ja7D*T6u5Dd$I8FBI)~-%>v&#w?B93CT2{+@v${t!%hT;rga(si zyKk_AM+180^AHSb;OHtux&)Ee@@y-n?P^G&-_qdWi>anZ$w$*V4b^l@RJitc$5&=p znv%;i8)D;`baG47!*AYy;_KpAMl1rXi!k2-DOdcn?z@OEZ(D0JtmNFu5pQPKbi`ZS zkadcJO#1j5DSFbubb%dhsoSKVwwomX#&Q|GBwUm4_MEDWN%eqZR8%qbJ_IhavhGSy zH$Rcxl&32axYYDeJ#v>LM4O$aui|Qfhr*So5?KE$8kI}_C~(~^U;5WxD2_zCwQK!E zjes)3RQx?-iE~nM-bnNl86}K*TCGvbr$%WJn=c%saHPpmrvZ3xPLMXsDO1+jE()S7 z$*1bd5{iX2XwFMpu27xfyTmAPQ(_%6(j)Ix2J0EBWst1`iNJaI!kK33XbI^*EDKa0 z$MWZ$v369$yP!#yA~7eK0y1UgvXOM5n8+rLHjIm;js}TjmcQuKS}#&QNbm)}Bs`JM zku<-&o+9tnRVGocycV&oW1#BTxwu>kOC!5jjD|qwA!VaMk&3X#MSb;TncJO_b>w>0 zt(+JfHQ2eiWT&mq;|Dvpg4mFlwRO?`#UtZm@kBD2Dim}bmv}L;!K^nimewS`uSSKY z26rr-%#0LAb8&T9X;dH#!Z{dQ(QpgQDoAulikn3VT2sKWx%G%Z)Z=>8`6)@dLch9V zI4Hk+MB1?)20Axk^T~biXF4)S>oBA*q?K;aMG;%bG97di{x)kUbri3$ux;yWOjA+! zsbuvm+3oDUhaaBD=+S8LRG**k(sH$CogtZb8piS(89&HU18aWhKTymmgjKAe0q|u zPtR}{RV=2@SHg;0fuLFKZdZ}I&5e{ z>u9tC{Cb6R@?FoX*fP{B>5d1h9kg4`&5uXhp_PVKweX??`Z=GTcs4*jm$}^IXnCM; z;g;KsVLMMPXfI>Fm)kJBbCgB5c8#im&-`^*MpSPTI7_N?gV4lS7`f{a3)lMMUP1H| zR;K#MAyn-}x%%xtOT9$a`2qw>J=MmN^IYH_=jZ0Tls$rW&3+$6>oq=f%uLsUqOvwM zaWX^<7HQWYbb)MMtZltT&1lctmV}?veeUJyzoKbvm+hn-CEPTcnr~sQHT^+Psy&C| zbQ7SfkkEj}a^B98FxRT$KLfo2Hd-n#32ku9X?v)m(RCWHClMR<+wEnA=B&Q3lxka! z)vo|p%DvHq)C!8k$K_RDUZhqvOY5Qab9_T)e3%|Bo=niH zGd+4m$#VMnm>#k?xqsb?<^7~}F)y)ii>7bdA zX-(O((4hH6pJ)nZ?n>UK7oQDf0Fg?~pSt4YtYlz$h$4``Y2(Q^^V+Ow<0i?X7fEiU zGQmnRU9)D*HtpUun?}9%DwJ$b#B3KE&qEND)0PL7njD1k-kuCwntkS0u3w+S8RCHo zrj?^FIqOV~<*MG5vC5f0e}+>V()vU3!R5Z){8EZp$;R_RFFJ`P2S{n_P~WjqyYbpe zlh*iH9PlwlYgLT8EajWE7vzQ~sk+=cMcPGamL4Y`c-ppnN8S?IQv5$J4=Nzje=7-?rRqDgsOtsre9QFXDLZc3f2)ucX$ zv@}hw+&2b-B}AW6TdG>!!(#J<$kun!$`%VZ?Xr%fMicb(sOnPH#*Eu)pMF#dM`P#X zm9HiwQO~+&(sjhtqd~ZUrnR|7YVsn*hTbyf(HLaPLI&^Aet9tbM zhAFo2WeL=|f=Y%pGbLUXwDEHB=mHh+t-$-bmc`Dx{BfVe*^d*rHI9yYDZx(@uy!}}PmI$9r1cGz%tnSEEY14+z}eI$ zeHdaMPx2``)1;5iHKa!pMd}hW7RBv)$A&HsJX=-sT_ng|3goeQQFXGbAo*0b4-h7u z4d5{ZeYtpa@JVS`UGXI9O02`Xf`2isd-Ebsb9C@U3!aiM`qR!iNQJ^##M+l~O&-Td z#nK!n7ae_PFWu+lGV0Q`$Cb`0l+?RPb)WY`B+_-L?pqEMIH>N|A4eKgsE8WbX2jT0 zqn{qs<7_lE`j?YNzeNR&FDZ1==noV*{>X@tNzq@+L#61y+^*>FQikrO_XZs$ELOX&{z>h2@OyuRv1_u^TzZy9Bu zrP^x;L_CDVv^CgAF`)ly9yjsy&6xA}@-3K@8KWn<%|jh2s}bpd!5E3D6^vuU<6hR9 z^w^Kir~)u|Fit{Qe_~V@qI;!}n<(o{VHwSOT_e!{SKZb2wyh)U{Y8sNwq@tzqMN<& zY0zVI&jl{_i{Us5of(rL7AIWC=s?waD#Y48p)h%3$G zwwZ|Erse*!`Eo)Ah|20;AsG9l6*|Q}mFx66!be?M)$ljr+<=K{lT9vCRfVi;F9N@K zodBUX_RvEoaF(8!mtIN{Wg0HAxH3GTrmN>Sue6hozuUnT`KG-lj?5er`YJ*Qfo}BS zfS#tRfH0{TJ4~Y#$RE#m%SHZ58@N4gC>1es1ZnH93jqLMYMCM&g(P~AM}~{!4%l;A z994+-;+){=c5-T3iY!A;VqTEj0a*Av+PMOZ5m@kW$dQc>g%kYZ*B+CIH}&u+>-l}R**6%l0mzsM3TT)p5>*?*393YTxCy+) zN%jhZ!Cw}>b|4bXJoK3N?UVv`if{6QO2!S4L?sYq9GY)2OHqQ~2ima^D>N#)7r_)B zDg126j4RSIgSm>b>NONKTyo%Kx7j^yPUbpD^u^GJjpaJNw0x;9PN3eDkGq`0c_etz z+2~GL#qftdao9I!XK9>QH~kSum*bGpXnRbQ)g(=NX){wM8<=?j~Wf zcq6By5N5Vkq~oOItX|o-TJ%;7`+$)hHgn`gy#?cAg+^G|s;iTdm8yUG`a!?U*o-J& z)tw$r78`CZX}^(cX+qw7k{Et?>|FjYx?-Sj!44X!r$VXDod+EE&nHy;Rv^uh_Pl^_ zHLKQ)(+@QA?9#H$bt2UaA>;RHwodvygp*C>3&zCPNai}yx;D?MU5&o+vd>fyn5WH= zG>Zp0_H8zOH24j&IJN`OtLtZ5l2Cf(rPiCcGc()>Wi@*$3P5zQyiH{(`GUsE(LMy5 zMQVYs8Z;@f>e|inf{r#&&zI+OeesTKp7z{^?M6zWHq+{Y$}v+7!I)O;rkMNr483@k zng^;h{pGfN*<8wj72|iFk$(+8*{_s1v7^LIVs9Zni^*LT<5kkGX!Bf#|X0 zlN^^}ztzsIJ>OskI;c~2uHFJYWMM73<`4+Ekh?VAzwS1tat%J&QR}DOgWJ8rKLI>} z8xsfyR-97X@(C4I%Wwjv!U&V-7yUWR4w7k9D09&kqRde=uv?gdBc}%*I8FI4@Kq_*M?fu2TlYmiT)+X8O( zQ00h_y5C)6BpW0Hr=!4Rjm6g&Yb@S}s#d`*UKE)^LtF9@gjDuN7M%j)&?zv1Q^4!N zL$Hek{TQcc-j|{tD;aLnt8$bW>O*Vr*u46WoubfMajjc=0Ap2Fd z7al-a=U}q%LNo-cY_I^mxBNvmycK0cg=C*!98Rq0sW?%&_Z;}!5EmMZih8Z@Tik`O zXG#mBe6 zUT=NbvV-t)=;LT`i&Uy~;7DokibURMb&6CzgJ@O@IMX@m)zJlS2`ky77*l9;#-sn@ zpk9tYWm<9POD|}NB^WpT*&G~XVynm*c!{-g6FK5-` z&Ech%=^TlS%A*1oAF(9bVdrxifVhsSVJE36#};L_FvXxMB+Q5^?Tj;lnr`98B-?r^V-nipu*3?hMR5A8)PQg0 z7JxSqtIDIpX%H8@4|QFDZ!&gUbx@HnHS~a*A$=_O`S^5r-c(&a9`o$|eX~Emp3vm- zm0BAw(L8zmP3_6Y{Oj;JiHlYyPM<_oMn+J+E86oHaEn z_Uz^SnXIw4lVy56qKy3P{JwiSY*p`T;J)-xue9BS7ojL6zgVqE%?rnFwwyk_FTa)h zXDUGhH)RM~AHHq&nf{;pO84f*P1G)9G(guhiOq8p7ghn&0!qW&cTksJbvJQfvVD$Pb6r%lHXXFdPjRXTe$4%K|%3UqE+v$xrr zPgwWS=23^@yvZ4t7;Tgq3p;761gpOJNTU#js_26x~3ToP2>-@;2}*SAW5*!dj**!3N}()peED;1v!qOhsRqv^Hw z7Jb5Gs8wIrsrQ=WjG5Fh*VqewyL{U4lDPX;&R({17gs6lzswU&WvBI<8{v2TMjs=p ziEtP;vbzOnd^u=m%d4RwPb&Sq zExdf-tH)IYqJRW$g$_L+hIiW%meMf{__Mp`jd3{F(GhaEhj)7owlXzaptA;IFnt9Q zkHpIB2AyOCnPjV~P+)Q?zr2!9j(%O0`})E{6$(Ui3-wP);6dRSqr1oIme`D+KQV`X zvTV}HwqEMNFkD8lHe^q38VaAhY+y%wO=ms2EK&uzEcR`=p5CbaMinz*WqEYm@k zc8#3ht5=d3yG#eb31%YCkKZ;n=oUdRM!tO4%pwM_)7K&)Q*5ziri&so3^P?;9pO|b z14I>7h}cWrfL6JXUvO6XTnSG#VC!nPHY&g zgL67SRvLOxu)LV4;Pv@4eO~7jt7lf>WMsRsgmK6E?xz_zb9kl>as>8=J)*wqQp9EX zGN<&%{)=+T;cj8Vb*Uz)vte4Bx^^L(t~jp;zp~5gFk-e%O&MkuDhRiB3vVJgsNw}B zwZYiyw+UkP47bzeWW~5mnd`s(QYz$n;*J^muCj20BUn^}TTF_f81n6h1E#C1xUDW!!K&KB!a2aUz6&?jYdh8sOY+~tkH`5pZiq&0G`Y|OL zI;~Za`gM_=io&GaQz&jX;mvxrgK1W)VHGAsp{>lSq3x&#t+>{qnVd=_Th$vC2oD|4 z{w5Jn%kEDMPCwxlqMAKE2k<`&Q*c&k*bBt-{XNBmHqqbo8R68$N|I{=z|F^e1MrEC zT4Bm=-dEMM33|e;x{b2-8<<<>YSr~CAb`; zkBW5lX__j6WDQ88B+;mHWrXOnYTtTo`f=)NM5Uxnomf%f$0V5D>q zoV7McNl{RzPZB_<*C`5h%}N8@nvo8i_ACiCIaTSEsy*^*=*-O!hVO+}JIr4Dylrb; zbFxVlJ{<;@A{hp~Xq9GDV$cXsjBf}zl2AR#I&?ZftXAjK%`V>1z;?VHBYiP}p&N1V zyNOciWB;UzyL5nVR)RMSuLk95|EUu0uiILYQonBXpKZ*NRjnL_I974(xLGWV=o&EcSBw}_Z36qL(5#EE~ zajm0^Jn4seL9CeeJcBNgNtZ!Kzs*s&+f}YF6CaN1u03e(c#!=~F36BB`^g>G>t8jr z865;Nh917DWMSyJVh&nE?}1$cWEaLe)q4q>Loc*#YC2VVUS*Mf#)^h*)K5~$i5oad z8jR`6t)0FqU*pi$`s{c(B0+ck&66L)jNL{`=KvpO!qisEH}T+-&u+gzP$P(C%H1Bx z*11GBQS@k8FbpcoANF8zV^6V)Ilwpq0?;#(E+Z({7WABd+#z|l?oh8=%R8PM7s@LJv`g|fSv?@a zhR75HEV@0rb3V!dnCGi5WU0?rJ;>PeA}bD+2y3cXRi`q)ij^N7VL59khgChRj$E`T z4oM@m1}Kt7(QybL9`Pth8_f$h6tEgn!VO77lY|nwmB&e);BslmdG9!Z$&HVO^KFxRgT+sGVUOm|P~xs` z$0wsKK7Yioc;iJ|X#i)Nzi10X{W__6HTGeEVE=By+S^0awP{<`cQ( z!$O=<5?p6|IOXqCJphOIkn!1uaD-8`7eDrTZ3hFL@YvnoC9G#qx0WzIIwT6-E8{V( z?8d13PZ+SflS&w*i!X}3-r42EMxa78E5iIe&{HLBb@YTV$S0qazgH27d03K$?CQ2j z8noH2_Hy5P;f)dc*KOg=%{Et&kig=#lM0Vma=*b56~;{B6+46O|&UO=f92mGX7 zKuH=xct@xN0-f>1;S3BqY=^y7l1~qLNQl&ZjR1viau20L-77hzhVH(yNn5T5EkCZW?PgDpI?fRxJzvuZM|2(P`3g=NeUg%jQkhC)I+mXaGl4#~<8T1ibt##V)Vr2NN7HrPwge4h zv_)JRUhPr5z6t_xs%waVbo1}FU;bSLPG-m#5j=7C5WaKb?ZGKOd9F9qq-N3 z#O_7ug9LbJAXp3v>N9jT6jgiDU{6TvKv3xN^>p~Y+-~+?E?@QSXFRY*7q&I5hIYJ= z)@J5+YOGcdeOi_YfXj(pX2K}*z{TPLQ@84AO5{q}0XhTG-#Owg5O-aLa7weI_=S*f zSm)NXHvglY40CNsWkII+t#ePmiMJD23|kTc5hjS_HcBHz1zt{=pLln8L+<|7a+b@2hHp~@kY4H^Te~bg6vQY>~Ptj6k}r9pep{Pf?MrJAaRCO zS9uRmLnR`GmC_B^Rv|Bye}Pbt7vMw^8XIJ~{IFe}&*l0b+b@d)iZNV zp-@=;V#O0LWNfS88Qm8*S7{kwbd`$|%pHl`%R|z3p>L$fDwHzSV!jHk{I%YmPk_Nb zOMj2fmuKoqw%+2>P*p6g(x;s$tB}JGhlL_J1dv9x51E*UflOIKOP$K#+}3N3P$0zQ zVNlfABZnvl9sqY%EGV zuwPYdVvhpNOaeX>B;A%h3Ym6{{2Ozvw-LU_Re750q3d&Ljy2<7TapW*#z}Tfd#jnM z4h&?h(KcATK|K`I_Im3^cb5xX+i>Exsi_s_cqjz9Thdb0A$EMNO5oX7Y9{ckoTL@n za*6q{_-YwVL|6NILo_N9yJ!??SsNX}Hc3)F+tQ~c+d!;9t+cch)wyG8v;;$AnzHNn zO2R_(XhgZ5DbEt*$ZD_(Bc2ImolfhL$g?G5^bg$0hFH(se>EYBEC0;c7po)u@_Ff@F zZOJY#D-@#Nu}`M#ldNDLjWYJp_?~@K@X?DAduqx*n(^UhIeT$7;~#M#vO8f#8HX$r zmYLy+A05pu)Bp-Sd@?M|`~Th%?A|#!)+-3Gd$X=OzO4PwoWF2^(>ebF54Rm?vXl z-ih#TA4X z3iO!foV}+4%u|71rUJiks&O0(ERb`~%lSe_d~`vEj|xt%v9Qc>F375!lV+TAb{Y%p zDQ_uZ4q@9)?l|jAGESO_AnYarrY6FfHJNgZP6Sq*%s9ykfk4HGudSF!p9$j?{4-8m z{*1uEf(9cUbQ~^0>P$HdGfo6SBnlEI6OPABI36?Mc+7+YEF1GZk_i%#FM*>`*fkJ!IE7{cZ_I>)ekN#pGl5@bf_8l`Z1;P?in$j~tb0NF-wXJ=hxk}7tM=57 z+5NHHtT*3Fx~u-M$JNqkUZzT59w+bb%gve|e!R!8t2Kp2)t?3aTz~zhexKrZy7k(A zfh#EO7rV_x`Bfh2jr|Y(c18oAUeT^>i!00buPR>upNOlax`KDV+HDX&$d+04$+vR< zoE2wv`R|hcSW>|kyy+PIOpg;3!KjZ}h8}>&)8U9~wBB{4kKYmOG0TC2a{q;{+&LWO zM}F@?9*Jb-zSPuE=(?;<4sD)ZUtTt+<@thMiHejN(ck?P$T{k7?(of;zFV3Pa(wXh zuzd!DtWN5ge1wk>e!UnLBIIK1i)NXeUI@Nj9}nkx_`MoRe~=UG&*ig)=6iWre_i4t W(#=7$9fx(d`ay$T&kBFT&;J1w`Svvc From 9e30fb54bca9888fc7487dfa8fe64a227881af9c Mon Sep 17 00:00:00 2001 From: lizdulac Date: Wed, 28 Feb 2024 14:16:12 -0500 Subject: [PATCH 10/46] Removed 'var' keyword from grammar and correctness test, and minor changes: ensured only one expression in grammar, turned off scanner debugging, resolved shift/reduce conflicts, ASTNode prettyprint can be called without operand. --- .../adios2/toolkit/derived/parser/ASTNode.cpp | 10 +- .../adios2/toolkit/derived/parser/ASTNode.h | 2 +- source/adios2/toolkit/derived/parser/lexer.l | 6 +- .../derived/parser/parser-test-driver.cpp | 19 - source/adios2/toolkit/derived/parser/parser.y | 69 +- .../derived/parser/pregen-source/Makefile | 2 +- .../derived/parser/pregen-source/lexer.cpp | 448 ++----------- .../derived/parser/pregen-source/lexer.h | 115 +--- .../derived/parser/pregen-source/parser.cpp | 319 +++++---- .../derived/parser/pregen-source/parser.h | 69 +- .../parser/pregen-source/parser.output | 622 +++++++++--------- .../derived/parser/pregen-source/simple-c | Bin 373624 -> 373136 bytes .../toolkit/derived/parser/test-driver.cpp | 19 + .../derived/TestBPDerivedCorrectness.cpp | 18 +- 14 files changed, 617 insertions(+), 1101 deletions(-) delete mode 100644 source/adios2/toolkit/derived/parser/parser-test-driver.cpp create mode 100644 source/adios2/toolkit/derived/parser/test-driver.cpp diff --git a/source/adios2/toolkit/derived/parser/ASTNode.cpp b/source/adios2/toolkit/derived/parser/ASTNode.cpp index 1f7fb90313..d44ae3264c 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.cpp +++ b/source/adios2/toolkit/derived/parser/ASTNode.cpp @@ -49,22 +49,22 @@ void ASTNode::insert_subexpr_n(ASTNode *subexpr, size_t index) std::string ASTNode::printpretty(std::string indent) { - std::string result = indent + opname + "\n"; + std::string result = indent + "Node: " + opname + "\n"; if (!alias.empty()) { - result += indent + "(alias: " + alias + ")\n"; + result += indent + " (alias: \"" + alias + "\")\n"; } if (!varname.empty()) { - result += indent + "(varname: " + varname + ")\n"; + result += indent + " (varname: \"" + varname + "\")\n"; } else if (!alias.empty()) { - result += indent + "(varname not found)\n"; + result += indent + " (varname not found)\n"; } if (!indices.empty()) { - result += indent + "(indices: [ "; + result += indent + " (indices: [ "; for (std::tuple idx: indices) { result += std::to_string(std::get<0>(idx)) + ":"; diff --git a/source/adios2/toolkit/derived/parser/ASTNode.h b/source/adios2/toolkit/derived/parser/ASTNode.h index 64feb45ad2..e4495eec23 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.h +++ b/source/adios2/toolkit/derived/parser/ASTNode.h @@ -21,7 +21,7 @@ class ASTNode void set_num_subexprs(size_t); void pushback_subexpr(ASTNode*); void insert_subexpr_n(ASTNode*, size_t); - std::string printpretty(std::string); + std::string printpretty(std::string = ""); std::vector get_subexprs(); std::string get_opname(); diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index 04a23e7d5f..45386646c0 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -79,7 +79,7 @@ #endif %} -%option noyywrap nounput noinput batch debug +%option noyywrap nounput noinput batch %{ // A number symbol corresponding to the value in S. @@ -88,7 +88,6 @@ %} op [-+*/^] -var "var" id [a-zA-Z][a-zA-Z_0-9_]* path [a-zA-Z][a-zA-Z0-9_\\./-]* int [0-9]+ @@ -108,7 +107,7 @@ blank [ \t\r] {blank}+ loc.step (); \n+ loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); -":=" return adios2::detail::parser::make_ASSIGN (loc); +"=" return adios2::detail::parser::make_ASSIGN (loc); "," return adios2::detail::parser::make_COMMA (loc); ":" return adios2::detail::parser::make_COLON (loc); "(" return adios2::detail::parser::make_L_PAREN (loc); @@ -117,7 +116,6 @@ blank [ \t\r] "]" return adios2::detail::parser::make_R_BRACE (loc); {int} return make_INT (yytext, loc); -{var} return adios2::detail::parser::make_VAR (loc); {op} return adios2::detail::parser::make_OPERATOR (yytext, loc); {id} return adios2::detail::parser::make_IDENTIFIER (yytext, loc); {path} return adios2::detail::parser::make_VARNAME (yytext, loc); diff --git a/source/adios2/toolkit/derived/parser/parser-test-driver.cpp b/source/adios2/toolkit/derived/parser/parser-test-driver.cpp deleted file mode 100644 index 4f69654a31..0000000000 --- a/source/adios2/toolkit/derived/parser/parser-test-driver.cpp +++ /dev/null @@ -1,19 +0,0 @@ -#include -#include -#include "ASTDriver.h" - -int -main (int argc, char *argv[]) -{ - adios2::detail::ASTDriver drv; - // char* str_expr = "one := 1\ntwo := 2\nthree := 3\n(one + two * three) * two * three"; - char* str_expr = "var x:= sim1/points/x\nvar y := sim1/points/y\nvar z:=sim_1/points-more/x[ , , ::5]\nvar a:=sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; - std::cout << "Parse input: " << str_expr << std::endl; - - adios2::detail::ASTNode *result = drv.parse(str_expr); - - std::cout << "Result: " << std::endl; - std::cout << result->printpretty(""); - - return 0; -} diff --git a/source/adios2/toolkit/derived/parser/parser.y b/source/adios2/toolkit/derived/parser/parser.y index 32d0192a1a..50dfc7669e 100644 --- a/source/adios2/toolkit/derived/parser/parser.y +++ b/source/adios2/toolkit/derived/parser/parser.y @@ -37,7 +37,7 @@ %define api.token.prefix {TOK_} %token - ASSIGN ":=" + ASSIGN "=" COMMA "," COLON ":" L_PAREN "(" @@ -45,65 +45,66 @@ L_BRACE "[" R_BRACE "]" ENDL "\n" - VAR "var" ; %token OPERATOR %token IDENTIFIER "identifier" %token VARNAME %token INT "number" -%nterm exp %nterm list %nterm >> indices_list %nterm > index +%left OPERATOR ENDL %% -%start unit; -unit: assignments exp { }; - -assignments: - %empty {} -| VAR assignment ENDL assignments {} +%start lines; +lines: + assignment ENDL lines {} +| exp {} +; assignment: IDENTIFIER ASSIGN VARNAME { drv.add_lookup_entry($1, $3); } | IDENTIFIER ASSIGN IDENTIFIER { drv.add_lookup_entry($1, $3); } | IDENTIFIER ASSIGN VARNAME L_BRACE indices_list R_BRACE { drv.add_lookup_entry($1, $3, $5); } -| IDENTIFIER ASSIGN IDENTIFIER L_BRACE indices_list R_BRACE { drv.add_lookup_entry($1, $3, $5); }; - -indices_list: -indices_list COMMA index { $1.push_back($3); $$ = $1; } -| index { $$ = {$1}; } -| %empty { $$ = {}; }; - -index: -INT COLON INT COLON INT { $$ = {$1, $3, $5}; } -| COLON INT COLON INT { $$ = {-1, $2, $4}; } -| INT COLON COLON INT { $$ = {$1, -1, $4}; } -| INT COLON INT COLON { $$ = {$1, $3, 1}; } -| INT COLON INT { $$ = {$1, $3, 1}; } -| COLON COLON INT { $$ = {-1, -1, $3}; } -| COLON INT COLON { $$ = {-1, $2, 1}; } -| COLON INT { $$ = {-1, $2, 1}; } -| INT COLON COLON { $$ = {$1, -1, 1}; } -| INT COLON { $$ = {$1, -1, 1}; } -| INT { $$ = {$1, $1, 1}; } -| %empty { $$ = {-1, -1, 1}; } +| IDENTIFIER ASSIGN IDENTIFIER L_BRACE indices_list R_BRACE { drv.add_lookup_entry($1, $3, $5); } ; exp: - "number" -| exp OPERATOR exp { drv.createNode($2, 2); } + "number" { } +| exp OPERATOR exp { drv.createNode($2, 2); } +| "(" exp ")" { } | IDENTIFIER "(" list ")" { drv.createNode($1, $3); } | IDENTIFIER "[" indices_list "]" { drv.createNode($1, $3); } | IDENTIFIER { drv.createNode($1); } -| "(" exp ")" { } +; + + +indices_list: + %empty { $$ = {}; } +| indices_list COMMA index { $1.push_back($3); $$ = $1; } +| index { $$ = {$1}; } +; + +index: + %empty { $$ = {-1, -1, 1}; } +| INT COLON INT COLON INT { $$ = {$1, $3, $5}; } +| COLON INT COLON INT { $$ = {-1, $2, $4}; } +| INT COLON COLON INT { $$ = {$1, -1, $4}; } +| INT COLON INT COLON { $$ = {$1, $3, 1}; } +| INT COLON INT { $$ = {$1, $3, 1}; } +| COLON COLON INT { $$ = {-1, -1, $3}; } +| COLON INT COLON { $$ = {-1, $2, 1}; } +| COLON INT { $$ = {-1, $2, 1}; } +| INT COLON COLON { $$ = {$1, -1, 1}; } +| INT COLON { $$ = {$1, -1, 1}; } +| INT { $$ = {$1, $1, 1}; } ; list: -exp COMMA list { $$ = $3 + 1; } + %empty { $$ = 0; } +| exp COMMA list { $$ = $3 + 1; } | exp { $$ = 1; } -| %empty { $$ = 0; } %% void diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Makefile b/source/adios2/toolkit/derived/parser/pregen-source/Makefile index 411381b732..73a1e490a3 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/Makefile +++ b/source/adios2/toolkit/derived/parser/pregen-source/Makefile @@ -3,7 +3,7 @@ PARSER_SOURCE = ../ OPT = -std=c++11 -I$(PARSER_SOURCE) -I./ BISON = bison -simple-c: $(PARSER_SOURCE)/parser-test-driver.cpp $(PARSER_SOURCE)/ASTDriver.cpp $(PARSER_SOURCE)/ASTNode.cpp lexer.cpp parser.cpp +simple-c: $(PARSER_SOURCE)/test-driver.cpp $(PARSER_SOURCE)/ASTDriver.cpp $(PARSER_SOURCE)/ASTNode.cpp lexer.cpp parser.cpp $(CC) $(OPT) $^ -o $@ lexer.h lexer.cpp: $(PARSER_SOURCE)/lexer.l diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index df1255e287..74ae734d89 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -6,14 +6,6 @@ /* A lexical scanner generated by flex */ -/* %not-for-header */ -/* %if-c-only */ -/* %if-not-reentrant */ - -/* %endif */ -/* %endif */ -/* %ok-for-header */ - #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 @@ -22,32 +14,16 @@ #define FLEX_BETA #endif -/* %if-c++-only */ -/* %endif */ - -/* %if-c-only */ - -/* %endif */ - -/* %if-c-only */ - -/* %endif */ - /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ -/* %if-c-only */ #include #include #include #include -/* %endif */ -/* %if-tables-serialization */ -/* %endif */ /* end standard C headers. */ -/* %if-c-or-c++ */ /* flex integer type definitions */ #ifndef FLEXINT_H @@ -117,11 +93,7 @@ typedef unsigned int flex_uint32_t; #endif /* ! FLEXINT_H */ -/* %endif */ - /* begin standard C++ headers. */ -/* %if-c++-only */ -/* %endif */ /* TODO: this is always defined, so inline it */ #define yyconst const @@ -132,24 +104,13 @@ typedef unsigned int flex_uint32_t; #define yynoreturn #endif -/* %not-for-header */ /* Returned upon end-of-file. */ #define YY_NULL 0 -/* %ok-for-header */ -/* %not-for-header */ /* Promotes a possibly negative, possibly signed char to an * integer in range [0..255] for use as an array index. */ #define YY_SC_TO_UI(c) ((YY_CHAR) (c)) -/* %ok-for-header */ - -/* %if-reentrant */ -/* %endif */ - -/* %if-not-reentrant */ - -/* %endif */ /* Enter a start condition. This macro really ought to take a parameter, * but we do it the disgusting crufty way forced on us by the ()-less @@ -195,15 +156,9 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif -/* %if-not-reentrant */ extern yy_size_t yyleng; -/* %endif */ -/* %if-c-only */ -/* %if-not-reentrant */ extern FILE *yyin, *yyout; -/* %endif */ -/* %endif */ #define EOB_ACT_CONTINUE_SCAN 0 #define EOB_ACT_END_OF_FILE 1 @@ -231,12 +186,7 @@ extern FILE *yyin, *yyout; #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { -/* %if-c-only */ FILE *yy_input_file; -/* %endif */ - -/* %if-c++-only */ -/* %endif */ char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */ @@ -297,18 +247,10 @@ struct yy_buffer_state }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ -/* %if-c-only Standard (non-C++) definition */ -/* %not-for-header */ -/* %if-not-reentrant */ - /* Stack of input buffers. */ static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ -/* %endif */ -/* %ok-for-header */ - -/* %endif */ /* We provide macros for accessing buffer states in case in the * future we want to put the buffer states in a more general @@ -324,10 +266,6 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ */ #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] -/* %if-c-only Standard (non-C++) definition */ - -/* %if-not-reentrant */ -/* %not-for-header */ /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ @@ -342,9 +280,6 @@ static int yy_start = 0; /* start state number */ * instead of setting up a fresh yyin. A bit of a hack ... */ static int yy_did_buffer_switch_on_eof; -/* %ok-for-header */ - -/* %endif */ void yyrestart ( FILE *input_file ); void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); @@ -363,8 +298,6 @@ YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); -/* %endif */ - void *yyalloc ( yy_size_t ); void *yyrealloc ( void *, yy_size_t ); void yyfree ( void * ); @@ -390,13 +323,10 @@ void yyfree ( void * ); } #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) -/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define yywrap() (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP - -#define FLEX_DEBUG typedef flex_uint8_t YY_CHAR; FILE *yyin = NULL, *yyout = NULL; @@ -412,31 +342,22 @@ extern char *yytext; #endif #define yytext_ptr yytext -/* %% [1.5] DFA */ - -/* %if-c-only Standard (non-C++) definition */ - static yy_state_type yy_get_previous_state ( void ); static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); static int yy_get_next_buffer ( void ); static void yynoreturn yy_fatal_error ( const char* msg ); -/* %endif */ - /* Done after the current pattern has been matched and before the * corresponding action - sets up yytext. */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ -/* %% [2.0] code to fiddle yytext and yyleng for yymore() goes here \ */\ yyleng = (yy_size_t) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ -/* %% [3.0] code to copy yytext_ptr to yytext[] goes here, if %array \ */\ (yy_c_buf_p) = yy_cp; -/* %% [4.0] data tables for the DFA and the user's section 1 definitions go here */ -#define YY_NUM_RULES 16 -#define YY_END_OF_BUFFER 17 +#define YY_NUM_RULES 15 +#define YY_END_OF_BUFFER 16 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -444,11 +365,11 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[26] = +static const flex_int16_t yy_accept[23] = { 0, - 0, 0, 17, 15, 1, 2, 6, 7, 12, 4, - 10, 5, 13, 8, 9, 13, 1, 2, 10, 3, - 14, 13, 13, 11, 0 + 0, 0, 16, 14, 1, 2, 6, 7, 11, 4, + 10, 5, 3, 12, 8, 9, 1, 2, 10, 13, + 12, 0 } ; static const YY_CHAR yy_ec[256] = @@ -462,10 +383,10 @@ static const YY_CHAR yy_ec[256] = 12, 1, 1, 1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 14, 9, 15, 6, 16, 1, 17, 13, 13, 13, + 14, 9, 15, 6, 16, 1, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 18, 13, 13, 13, 19, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -483,57 +404,49 @@ static const YY_CHAR yy_ec[256] = 1, 1, 1, 1, 1 } ; -static const YY_CHAR yy_meta[20] = +static const YY_CHAR yy_meta[17] = { 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, - 1, 1, 2, 1, 1, 2, 2, 2, 2 + 1, 1, 2, 1, 1, 2 } ; -static const flex_int16_t yy_base[28] = +static const flex_int16_t yy_base[25] = { 0, - 0, 0, 38, 39, 35, 33, 39, 39, 39, 39, - 25, 22, 12, 39, 39, 14, 31, 29, 20, 39, - 0, 12, 7, 11, 39, 25, 24 + 0, 0, 29, 30, 26, 24, 30, 30, 30, 30, + 16, 30, 30, 9, 30, 30, 23, 21, 13, 0, + 11, 30, 20, 19 } ; -static const flex_int16_t yy_def[28] = +static const flex_int16_t yy_def[25] = { 0, - 25, 1, 25, 25, 25, 25, 25, 25, 25, 25, - 25, 25, 26, 25, 25, 26, 25, 25, 25, 25, - 27, 16, 16, 16, 0, 25, 25 + 22, 1, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 23, 22, 22, 22, 22, 22, 24, + 23, 0, 22, 22 } ; -static const flex_int16_t yy_nxt[59] = +static const flex_int16_t yy_nxt[47] = { 0, 4, 5, 6, 7, 8, 9, 10, 9, 4, 11, - 12, 4, 13, 14, 15, 4, 13, 13, 16, 21, - 21, 21, 21, 22, 24, 21, 22, 22, 22, 19, - 23, 18, 17, 20, 19, 18, 17, 25, 3, 25, - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25 + 12, 13, 14, 15, 16, 4, 20, 20, 20, 20, + 20, 21, 19, 18, 17, 19, 18, 17, 22, 3, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22 } ; -static const flex_int16_t yy_chk[59] = +static const flex_int16_t yy_chk[47] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 13, - 13, 16, 16, 23, 23, 27, 26, 24, 22, 19, - 16, 18, 17, 12, 11, 6, 5, 3, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, - 25, 25, 25, 25, 25, 25, 25, 25 + 1, 1, 1, 1, 1, 1, 14, 14, 21, 21, + 24, 23, 19, 18, 17, 11, 6, 5, 3, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22 } ; static yy_state_type yy_last_accepting_state; static char *yy_last_accepting_cpos; extern int yy_flex_debug; -int yy_flex_debug = 1; - -static const flex_int16_t yy_rule_linenum[16] = - { 0, - 109, 110, 112, 113, 114, 115, 116, 117, 118, 120, - 121, 122, 123, 124, 125 - } ; +int yy_flex_debug = 0; /* The intent behind this definition is that it'll catch * any uses of REJECT which flex missed. @@ -552,7 +465,7 @@ char *yytext; #include #include "ASTDriver.h" #include "parser.h" -#line 555 "lexer.cpp" +#line 468 "lexer.cpp" #line 12 "..//lexer.l" #if defined __clang__ # define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) @@ -622,18 +535,18 @@ char *yytext; #if defined GCC_VERSION && 900 <= GCC_VERSION # pragma GCC diagnostic ignored "-Wuseless-cast" #endif -#line 625 "lexer.cpp" +#line 538 "lexer.cpp" #define YY_NO_INPUT 1 #line 85 "..//lexer.l" // A number symbol corresponding to the value in S. adios2::detail::parser::symbol_type make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); -#line 631 "lexer.cpp" -#line 98 "..//lexer.l" +#line 544 "lexer.cpp" +#line 97 "..//lexer.l" // Code run each time a pattern is matched. # define YY_USER_ACTION loc.columns (yyleng); -#line 635 "lexer.cpp" -#line 636 "lexer.cpp" +#line 548 "lexer.cpp" +#line 549 "lexer.cpp" #define INITIAL 0 @@ -642,28 +555,15 @@ char *yytext; * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ -/* %if-c-only */ #include -/* %endif */ -/* %if-c++-only */ -/* %endif */ #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif -/* %if-c-only Reentrant structure and macros (non-C++). */ -/* %if-reentrant */ -/* %if-c-only */ - static int yy_init_globals ( void ); -/* %endif */ -/* %if-reentrant */ -/* %endif */ -/* %endif End reentrant structures and macros. */ - /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ @@ -693,9 +593,6 @@ int yyget_lineno ( void ); void yyset_lineno ( int _line_number ); -/* %if-bison-bridge */ -/* %endif */ - /* Macros after this point can all be overridden by user definitions in * section 1. */ @@ -708,13 +605,9 @@ extern int yywrap ( void ); #endif #endif -/* %not-for-header */ #ifndef YY_NO_UNPUT #endif -/* %ok-for-header */ - -/* %endif */ #ifndef yytext_ptr static void yy_flex_strncpy ( char *, const char *, int ); @@ -725,22 +618,14 @@ static int yy_flex_strlen ( const char * ); #endif #ifndef YY_NO_INPUT -/* %if-c-only Standard (non-C++) definition */ -/* %not-for-header */ #ifdef __cplusplus static int yyinput ( void ); #else static int input ( void ); #endif -/* %ok-for-header */ -/* %endif */ #endif -/* %if-c-only */ - -/* %endif */ - /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #ifdef __ia64__ @@ -753,14 +638,10 @@ static int input ( void ); /* Copy whatever the last rule matched to the standard output. */ #ifndef ECHO -/* %if-c-only Standard (non-C++) definition */ /* This used to be an fputs(), but since the string might contain NUL's, * we now use fwrite(). */ #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) -/* %endif */ -/* %if-c++-only C++ definition */ -/* %endif */ #endif /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, @@ -768,7 +649,6 @@ static int input ( void ); */ #ifndef YY_INPUT #define YY_INPUT(buf,result,max_size) \ -/* %% [5.0] fread()/read() definition of YY_INPUT goes here unless we're doing C++ \ */\ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ @@ -797,8 +677,6 @@ static int input ( void ); } \ }\ \ -/* %if-c++-only C++ definition \ */\ -/* %endif */ #endif @@ -817,37 +695,20 @@ static int input ( void ); /* Report a fatal error. */ #ifndef YY_FATAL_ERROR -/* %if-c-only */ #define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ #endif -/* %if-tables-serialization structures and prototypes */ -/* %not-for-header */ -/* %ok-for-header */ - -/* %not-for-header */ -/* %tables-yydmap generated elements */ -/* %endif */ /* end tables serialization structures and prototypes */ -/* %ok-for-header */ - /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 -/* %if-c-only Standard (non-C++) definition */ extern int yylex (void); #define YY_DECL int yylex (void) -/* %endif */ -/* %if-c++-only C++ definition */ -/* %endif */ #endif /* !YY_DECL */ /* Code executed at the beginning of each rule, after yytext and yyleng @@ -862,11 +723,9 @@ extern int yylex (void); #define YY_BREAK /*LINTED*/break; #endif -/* %% [6.0] YY_RULE_SETUP definition goes here */ #define YY_RULE_SETUP \ YY_USER_ACTION -/* %not-for-header */ /** The main scanner function which does all the work. */ YY_DECL @@ -887,18 +746,10 @@ YY_DECL (yy_start) = 1; /* first start state */ if ( ! yyin ) -/* %if-c-only */ yyin = stdin; -/* %endif */ -/* %if-c++-only */ -/* %endif */ if ( ! yyout ) -/* %if-c-only */ yyout = stdout; -/* %endif */ -/* %if-c++-only */ -/* %endif */ if ( ! YY_CURRENT_BUFFER ) { yyensure_buffer_stack (); @@ -910,21 +761,19 @@ YY_DECL } { -/* %% [7.0] user's declarations go here */ -#line 101 "..//lexer.l" +#line 100 "..//lexer.l" -#line 104 "..//lexer.l" +#line 103 "..//lexer.l" // A handy shortcut to the location held by the adios2::detail::ASTDriver. adios2::detail::location& loc = drv.location; // Code run each time yylex is called. loc.step (); -#line 923 "lexer.cpp" +#line 773 "lexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { -/* %% [8.0] yymore()-related code goes here */ yy_cp = (yy_c_buf_p); /* Support of yytext. */ @@ -935,7 +784,6 @@ YY_DECL */ yy_bp = yy_cp; -/* %% [9.0] code to set up and find next match goes here */ yy_current_state = (yy_start); yy_match: do @@ -949,46 +797,25 @@ YY_DECL while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 26 ) + if ( yy_current_state >= 23 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 25 ); + while ( yy_current_state != 22 ); yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); yy_find_action: -/* %% [10.0] code to find the action number goes here */ yy_act = yy_accept[yy_current_state]; YY_DO_BEFORE_ACTION; -/* %% [11.0] code for yylineno update goes here */ - do_action: /* This label is used only to access EOF actions. */ -/* %% [12.0] debug code goes here */ - if ( yy_flex_debug ) - { - if ( yy_act == 0 ) - fprintf( stderr, "--scanner backing up\n" ); - else if ( yy_act < 16 ) - fprintf( stderr, "--accepting rule at line %ld (\"%s\")\n", - (long)yy_rule_linenum[yy_act], yytext ); - else if ( yy_act == 16 ) - fprintf( stderr, "--accepting default rule (\"%s\")\n", - yytext ); - else if ( yy_act == 17 ) - fprintf( stderr, "--(end of buffer or a NUL)\n" ); - else - fprintf( stderr, "--EOF (start condition %d)\n", YY_START ); - } - switch ( yy_act ) { /* beginning of action switch */ -/* %% [13.0] actions go here */ case 0: /* must back up */ /* undo the effects of YY_DO_BEFORE_ACTION */ *yy_cp = (yy_hold_char); @@ -998,93 +825,88 @@ YY_DECL case 1: YY_RULE_SETUP -#line 109 "..//lexer.l" +#line 108 "..//lexer.l" loc.step (); YY_BREAK case 2: /* rule 2 can match eol */ YY_RULE_SETUP -#line 110 "..//lexer.l" +#line 109 "..//lexer.l" loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); YY_BREAK case 3: YY_RULE_SETUP -#line 112 "..//lexer.l" +#line 111 "..//lexer.l" return adios2::detail::parser::make_ASSIGN (loc); YY_BREAK case 4: YY_RULE_SETUP -#line 113 "..//lexer.l" +#line 112 "..//lexer.l" return adios2::detail::parser::make_COMMA (loc); YY_BREAK case 5: YY_RULE_SETUP -#line 114 "..//lexer.l" +#line 113 "..//lexer.l" return adios2::detail::parser::make_COLON (loc); YY_BREAK case 6: YY_RULE_SETUP -#line 115 "..//lexer.l" +#line 114 "..//lexer.l" return adios2::detail::parser::make_L_PAREN (loc); YY_BREAK case 7: YY_RULE_SETUP -#line 116 "..//lexer.l" +#line 115 "..//lexer.l" return adios2::detail::parser::make_R_PAREN (loc); YY_BREAK case 8: YY_RULE_SETUP -#line 117 "..//lexer.l" +#line 116 "..//lexer.l" return adios2::detail::parser::make_L_BRACE (loc); YY_BREAK case 9: YY_RULE_SETUP -#line 118 "..//lexer.l" +#line 117 "..//lexer.l" return adios2::detail::parser::make_R_BRACE (loc); YY_BREAK case 10: YY_RULE_SETUP -#line 120 "..//lexer.l" +#line 119 "..//lexer.l" return make_INT (yytext, loc); YY_BREAK case 11: YY_RULE_SETUP -#line 121 "..//lexer.l" -return adios2::detail::parser::make_VAR (loc); - YY_BREAK -case 12: -YY_RULE_SETUP -#line 122 "..//lexer.l" +#line 120 "..//lexer.l" return adios2::detail::parser::make_OPERATOR (yytext, loc); YY_BREAK -case 13: +case 12: YY_RULE_SETUP -#line 123 "..//lexer.l" +#line 121 "..//lexer.l" return adios2::detail::parser::make_IDENTIFIER (yytext, loc); YY_BREAK -case 14: +case 13: YY_RULE_SETUP -#line 124 "..//lexer.l" +#line 122 "..//lexer.l" return adios2::detail::parser::make_VARNAME (yytext, loc); YY_BREAK -case 15: +case 14: YY_RULE_SETUP -#line 125 "..//lexer.l" +#line 123 "..//lexer.l" { throw adios2::detail::parser::syntax_error (loc, "invalid character: " + std::string(yytext)); } YY_BREAK case YY_STATE_EOF(INITIAL): -#line 129 "..//lexer.l" +#line 127 "..//lexer.l" return adios2::detail::parser::make_YYEOF (loc); YY_BREAK -case 16: +case 15: YY_RULE_SETUP -#line 130 "..//lexer.l" +#line 128 "..//lexer.l" ECHO; YY_BREAK -#line 1087 "lexer.cpp" +#line 909 "lexer.cpp" case YY_END_OF_BUFFER: { @@ -1107,11 +929,7 @@ ECHO; * back-up) that will match for the new input source. */ (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; -/* %if-c-only */ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; -/* %endif */ -/* %if-c++-only */ -/* %endif */ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; } @@ -1153,7 +971,6 @@ ECHO; else { -/* %% [14.0] code to do back-up for compressed tables and set up yy_cp goes here */ yy_cp = (yy_last_accepting_cpos); yy_current_state = (yy_last_accepting_state); goto yy_find_action; @@ -1221,13 +1038,6 @@ ECHO; } /* end of scanning one token */ } /* end of user's declarations */ } /* end of yylex */ -/* %ok-for-header */ - -/* %if-c++-only */ -/* %not-for-header */ -/* %ok-for-header */ - -/* %endif */ /* yy_get_next_buffer - try to read in a new buffer * @@ -1236,11 +1046,7 @@ ECHO; * EOB_ACT_CONTINUE_SCAN - continue scanning from current position * EOB_ACT_END_OF_FILE - end of file */ -/* %if-c-only */ static int yy_get_next_buffer (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; char *source = (yytext_ptr); @@ -1378,22 +1184,15 @@ static int yy_get_next_buffer (void) /* yy_get_previous_state - get the state just before the EOB char was reached */ -/* %if-c-only */ -/* %not-for-header */ static yy_state_type yy_get_previous_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { yy_state_type yy_current_state; char *yy_cp; -/* %% [15.0] code to get the start state into yy_current_state goes here */ yy_current_state = (yy_start); for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) { -/* %% [16.0] code to find the next state goes here */ YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); if ( yy_accept[yy_current_state] ) { @@ -1403,7 +1202,7 @@ static int yy_get_next_buffer (void) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 26 ) + if ( yy_current_state >= 23 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -1417,15 +1216,10 @@ static int yy_get_next_buffer (void) * synopsis * next_state = yy_try_NUL_trans( current_state ); */ -/* %if-c-only */ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { int yy_is_jam; - /* %% [17.0] code to find the next state, and perhaps do backing up, goes here */ - char *yy_cp = (yy_c_buf_p); + char *yy_cp = (yy_c_buf_p); YY_CHAR yy_c = 1; if ( yy_accept[yy_current_state] ) @@ -1436,22 +1230,19 @@ static int yy_get_next_buffer (void) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 26 ) + if ( yy_current_state >= 23 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 25); + yy_is_jam = (yy_current_state == 22); return yy_is_jam ? 0 : yy_current_state; } #ifndef YY_NO_UNPUT -/* %if-c-only */ -/* %endif */ #endif -/* %if-c-only */ #ifndef YY_NO_INPUT #ifdef __cplusplus static int yyinput (void) @@ -1459,9 +1250,6 @@ static int yy_get_next_buffer (void) static int input (void) #endif -/* %endif */ -/* %if-c++-only */ -/* %endif */ { int c; @@ -1525,24 +1313,16 @@ static int yy_get_next_buffer (void) *(yy_c_buf_p) = '\0'; /* preserve yytext */ (yy_hold_char) = *++(yy_c_buf_p); -/* %% [19.0] update BOL and yylineno */ - return c; } -/* %if-c-only */ #endif /* ifndef YY_NO_INPUT */ -/* %endif */ /** Immediately switch to a different input stream. * @param input_file A readable stream. * * @note This function does not reset the start condition to @c INITIAL . */ -/* %if-c-only */ void yyrestart (FILE * input_file ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { if ( ! YY_CURRENT_BUFFER ){ @@ -1555,18 +1335,11 @@ static int yy_get_next_buffer (void) yy_load_buffer_state( ); } -/* %if-c++-only */ -/* %endif */ - /** Switch to a different input buffer. * @param new_buffer The new input buffer. * */ -/* %if-c-only */ void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { /* TODO. We should be able to replace this entire function body @@ -1597,19 +1370,11 @@ static int yy_get_next_buffer (void) (yy_did_buffer_switch_on_eof) = 1; } -/* %if-c-only */ static void yy_load_buffer_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; -/* %if-c-only */ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; -/* %endif */ -/* %if-c++-only */ -/* %endif */ (yy_hold_char) = *(yy_c_buf_p); } @@ -1619,11 +1384,7 @@ static void yy_load_buffer_state (void) * * @return the allocated buffer state. */ -/* %if-c-only */ YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { YY_BUFFER_STATE b; @@ -1647,18 +1408,11 @@ static void yy_load_buffer_state (void) return b; } -/* %if-c++-only */ -/* %endif */ - /** Destroy the buffer. * @param b a buffer created with yy_create_buffer() * */ -/* %if-c-only */ void yy_delete_buffer (YY_BUFFER_STATE b ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { if ( ! b ) @@ -1677,22 +1431,14 @@ static void yy_load_buffer_state (void) * This function is sometimes called more than once on the same buffer, * such as during a yyrestart() or at EOF. */ -/* %if-c-only */ static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { int oerrno = errno; yy_flush_buffer( b ); -/* %if-c-only */ b->yy_input_file = file; -/* %endif */ -/* %if-c++-only */ -/* %endif */ b->yy_fill_buffer = 1; /* If b is the current buffer, then yy_init_buffer was _probably_ @@ -1704,13 +1450,8 @@ static void yy_load_buffer_state (void) b->yy_bs_column = 0; } -/* %if-c-only */ - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; -/* %endif */ -/* %if-c++-only */ -/* %endif */ errno = oerrno; } @@ -1718,11 +1459,7 @@ static void yy_load_buffer_state (void) * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. * */ -/* %if-c-only */ void yy_flush_buffer (YY_BUFFER_STATE b ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { if ( ! b ) return; @@ -1745,18 +1482,13 @@ static void yy_load_buffer_state (void) yy_load_buffer_state( ); } -/* %if-c-or-c++ */ /** Pushes the new state onto the stack. The new state becomes * the current state. This function will allocate the stack * if necessary. * @param new_buffer The new state. * */ -/* %if-c-only */ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { if (new_buffer == NULL) return; @@ -1781,18 +1513,12 @@ void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) yy_load_buffer_state( ); (yy_did_buffer_switch_on_eof) = 1; } -/* %endif */ -/* %if-c-or-c++ */ /** Removes and deletes the top of the stack, if present. * The next element becomes the new top. * */ -/* %if-c-only */ void yypop_buffer_state (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { if (!YY_CURRENT_BUFFER) return; @@ -1807,17 +1533,11 @@ void yypop_buffer_state (void) (yy_did_buffer_switch_on_eof) = 1; } } -/* %endif */ -/* %if-c-or-c++ */ /* Allocates the stack if it does not exist. * Guarantees space for at least one push. */ -/* %if-c-only */ static void yyensure_buffer_stack (void) -/* %endif */ -/* %if-c++-only */ -/* %endif */ { yy_size_t num_to_alloc; @@ -1859,9 +1579,7 @@ static void yyensure_buffer_stack (void) (yy_buffer_stack_max) = num_to_alloc; } } -/* %endif */ -/* %if-c-only */ /** Setup the input buffer state to scan directly from a user-specified character buffer. * @param base the character buffer * @param size the size in bytes of the character buffer @@ -1896,9 +1614,7 @@ YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) return b; } -/* %endif */ -/* %if-c-only */ /** Setup the input buffer state to scan a string. The next call to yylex() will * scan from a @e copy of @a str. * @param yystr a NUL-terminated string to scan @@ -1912,9 +1628,7 @@ YY_BUFFER_STATE yy_scan_string (const char * yystr ) return yy_scan_bytes( yystr, (int) strlen(yystr) ); } -/* %endif */ -/* %if-c-only */ /** Setup the input buffer state to scan the given bytes. The next call to yylex() will * scan from a @e copy of @a bytes. * @param yybytes the byte buffer to scan @@ -1951,21 +1665,16 @@ YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, yy_size_t _yybytes_len ) return b; } -/* %endif */ #ifndef YY_EXIT_FAILURE #define YY_EXIT_FAILURE 2 #endif -/* %if-c-only */ static void yynoreturn yy_fatal_error (const char* msg ) { fprintf( stderr, "%s\n", msg ); exit( YY_EXIT_FAILURE ); } -/* %endif */ -/* %if-c++-only */ -/* %endif */ /* Redefine yyless() so it works in section 3 code. */ @@ -1986,10 +1695,6 @@ static void yynoreturn yy_fatal_error (const char* msg ) /* Accessor methods (get/set functions) to struct members. */ -/* %if-c-only */ -/* %if-reentrant */ -/* %endif */ - /** Get the current line number. * */ @@ -2032,9 +1737,6 @@ char *yyget_text (void) return yytext; } -/* %if-reentrant */ -/* %endif */ - /** Set the current line number. * @param _line_number line number * @@ -2071,14 +1773,6 @@ void yyset_debug (int _bdebug ) yy_flex_debug = _bdebug ; } -/* %endif */ - -/* %if-reentrant */ -/* %if-bison-bridge */ -/* %endif */ -/* %endif if-c-only */ - -/* %if-c-only */ static int yy_init_globals (void) { /* Initialization is the same as for the non-reentrant scanner. @@ -2106,9 +1800,7 @@ static int yy_init_globals (void) */ return 0; } -/* %endif */ -/* %if-c-only SNIP! this currently causes conflicts with the c++ scanner */ /* yylex_destroy is for both reentrant and non-reentrant scanners. */ int yylex_destroy (void) { @@ -2128,11 +1820,8 @@ int yylex_destroy (void) * yylex() is called, initialization will occur. */ yy_init_globals( ); -/* %if-reentrant */ -/* %endif */ return 0; } -/* %endif */ /* * Internal utility routines. @@ -2182,14 +1871,9 @@ void yyfree (void * ptr ) free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ } -/* %if-tables-serialization definitions */ -/* %define-yytables The name for this specific scanner's tables. */ #define YYTABLES_NAME "yytables" -/* %endif */ - -/* %ok-for-header */ -#line 130 "..//lexer.l" +#line 128 "..//lexer.l" adios2::detail::parser::symbol_type diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h index f6edccecf8..5e5e9be909 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h @@ -10,8 +10,6 @@ /* A lexical scanner generated by flex */ -/* %not-for-header */ - #define FLEX_SCANNER #define YY_FLEX_MAJOR_VERSION 2 #define YY_FLEX_MINOR_VERSION 6 @@ -20,32 +18,16 @@ #define FLEX_BETA #endif -/* %if-c++-only */ -/* %endif */ - -/* %if-c-only */ - -/* %endif */ - -/* %if-c-only */ - -/* %endif */ - /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ -/* %if-c-only */ #include #include #include #include -/* %endif */ -/* %if-tables-serialization */ -/* %endif */ /* end standard C headers. */ -/* %if-c-or-c++ */ /* flex integer type definitions */ #ifndef FLEXINT_H @@ -115,11 +97,7 @@ typedef unsigned int flex_uint32_t; #endif /* ! FLEXINT_H */ -/* %endif */ - /* begin standard C++ headers. */ -/* %if-c++-only */ -/* %endif */ /* TODO: this is always defined, so inline it */ #define yyconst const @@ -130,17 +108,6 @@ typedef unsigned int flex_uint32_t; #define yynoreturn #endif -/* %not-for-header */ - -/* %not-for-header */ - -/* %if-reentrant */ -/* %endif */ - -/* %if-not-reentrant */ - -/* %endif */ - /* Size of default input buffer. */ #ifndef YY_BUF_SIZE #ifdef __ia64__ @@ -164,26 +131,15 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif -/* %if-not-reentrant */ extern yy_size_t yyleng; -/* %endif */ -/* %if-c-only */ -/* %if-not-reentrant */ extern FILE *yyin, *yyout; -/* %endif */ -/* %endif */ #ifndef YY_STRUCT_YY_BUFFER_STATE #define YY_STRUCT_YY_BUFFER_STATE struct yy_buffer_state { -/* %if-c-only */ FILE *yy_input_file; -/* %endif */ - -/* %if-c++-only */ -/* %endif */ char *yy_ch_buf; /* input buffer */ char *yy_buf_pos; /* current position in input buffer */ @@ -230,18 +186,6 @@ struct yy_buffer_state }; #endif /* !YY_STRUCT_YY_BUFFER_STATE */ -/* %if-c-only Standard (non-C++) definition */ -/* %not-for-header */ - -/* %endif */ - -/* %if-c-only Standard (non-C++) definition */ - -/* %if-not-reentrant */ -/* %not-for-header */ - -/* %endif */ - void yyrestart ( FILE *input_file ); void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); @@ -254,20 +198,15 @@ YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); -/* %endif */ - void *yyalloc ( yy_size_t ); void *yyrealloc ( void *, yy_size_t ); void yyfree ( void * ); -/* %% [1.0] yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here */ /* Begin user sect3 */ #define yywrap() (/*CONSTCOND*/1) #define YY_SKIP_YYWRAP -#define FLEX_DEBUG - extern int yylineno; extern char *yytext; @@ -276,10 +215,6 @@ extern char *yytext; #endif #define yytext_ptr yytext -/* %if-c-only Standard (non-C++) definition */ - -/* %endif */ - #ifdef YY_HEADER_EXPORT_START_CONDITIONS #define INITIAL 0 @@ -290,26 +225,13 @@ extern char *yytext; * down here because we want the user's section 1 to have been scanned first. * The user has a chance to override it with an option. */ -/* %if-c-only */ #include -/* %endif */ -/* %if-c++-only */ -/* %endif */ #endif #ifndef YY_EXTRA_TYPE #define YY_EXTRA_TYPE void * #endif -/* %if-c-only Reentrant structure and macros (non-C++). */ -/* %if-reentrant */ -/* %if-c-only */ - -/* %endif */ -/* %if-reentrant */ -/* %endif */ -/* %endif End reentrant structures and macros. */ - /* Accessor methods to globals. These are made visible to non-reentrant scanners for convenience. */ @@ -339,9 +261,6 @@ int yyget_lineno ( void ); void yyset_lineno ( int _line_number ); -/* %if-bison-bridge */ -/* %endif */ - /* Macros after this point can all be overridden by user definitions in * section 1. */ @@ -354,10 +273,6 @@ extern int yywrap ( void ); #endif #endif -/* %not-for-header */ - -/* %endif */ - #ifndef yytext_ptr static void yy_flex_strncpy ( char *, const char *, int ); #endif @@ -367,16 +282,9 @@ static int yy_flex_strlen ( const char * ); #endif #ifndef YY_NO_INPUT -/* %if-c-only Standard (non-C++) definition */ -/* %not-for-header */ -/* %endif */ #endif -/* %if-c-only */ - -/* %endif */ - /* Amount of stuff to slurp up with each read. */ #ifndef YY_READ_BUF_SIZE #ifdef __ia64__ @@ -392,38 +300,19 @@ static int yy_flex_strlen ( const char * ); #define YY_START_STACK_INCR 25 #endif -/* %if-tables-serialization structures and prototypes */ -/* %not-for-header */ - -/* %not-for-header */ - /* Default declaration of generated scanner - a define so the user can * easily add parameters. */ #ifndef YY_DECL #define YY_DECL_IS_OURS 1 -/* %if-c-only Standard (non-C++) definition */ extern int yylex (void); #define YY_DECL int yylex (void) -/* %endif */ -/* %if-c++-only C++ definition */ -/* %endif */ #endif /* !YY_DECL */ -/* %not-for-header */ - -/* %if-c++-only */ -/* %not-for-header */ - -/* %endif */ - /* yy_get_previous_state - get the state just before the EOB char was reached */ -/* %if-c-only */ -/* %not-for-header */ - #undef YY_NEW_FILE #undef YY_FLUSH_BUFFER #undef yy_set_bol @@ -581,9 +470,9 @@ extern int yylex (void); #undef yyTABLES_NAME #endif -#line 130 "..//lexer.l" +#line 128 "..//lexer.l" -#line 587 "lexer.h" +#line 476 "lexer.h" #undef yyIN_HEADER #endif /* yyHEADER_H */ diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp index 5286dcd0cd..fbc7a98f38 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp @@ -210,7 +210,6 @@ namespace adios2 { namespace detail { switch (that.kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.YY_MOVE_OR_COPY< int > (YY_MOVE (that.value)); break; @@ -245,7 +244,6 @@ namespace adios2 { namespace detail { switch (that.kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.move< int > (YY_MOVE (that.value)); break; @@ -280,7 +278,6 @@ namespace adios2 { namespace detail { switch (that.kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.copy< int > (that.value); break; @@ -314,7 +311,6 @@ namespace adios2 { namespace detail { switch (that.kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.move< int > (that.value); break; @@ -603,7 +599,6 @@ namespace adios2 { namespace detail { switch (yyr1_[yyn]) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list yylhs.value.emplace< int > (); break; @@ -642,194 +637,188 @@ namespace adios2 { namespace detail { { switch (yyn) { - case 2: // unit: assignments exp + case 2: // lines: assignment "\n" lines #line 62 "..//parser.y" - { } -#line 649 "parser.cpp" + {} +#line 644 "parser.cpp" break; - case 3: // assignments: %empty -#line 65 "..//parser.y" - {} -#line 655 "parser.cpp" + case 3: // lines: exp +#line 63 "..//parser.y" + {} +#line 650 "parser.cpp" break; - case 4: // assignments: "var" assignment "\n" assignments -#line 66 "..//parser.y" - {} -#line 661 "parser.cpp" - break; - - case 5: // assignment: "identifier" ":=" VARNAME -#line 69 "..//parser.y" + case 4: // assignment: "identifier" "=" VARNAME +#line 67 "..//parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } -#line 667 "parser.cpp" +#line 656 "parser.cpp" break; - case 6: // assignment: "identifier" ":=" "identifier" -#line 70 "..//parser.y" + case 5: // assignment: "identifier" "=" "identifier" +#line 68 "..//parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } -#line 673 "parser.cpp" +#line 662 "parser.cpp" break; - case 7: // assignment: "identifier" ":=" VARNAME "[" indices_list "]" -#line 71 "..//parser.y" + case 6: // assignment: "identifier" "=" VARNAME "[" indices_list "]" +#line 69 "..//parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } -#line 679 "parser.cpp" +#line 668 "parser.cpp" break; - case 8: // assignment: "identifier" ":=" "identifier" "[" indices_list "]" -#line 72 "..//parser.y" + case 7: // assignment: "identifier" "=" "identifier" "[" indices_list "]" +#line 70 "..//parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } -#line 685 "parser.cpp" +#line 674 "parser.cpp" + break; + + case 8: // exp: "number" +#line 74 "..//parser.y" + { } +#line 680 "parser.cpp" break; - case 9: // indices_list: indices_list "," index + case 9: // exp: exp OPERATOR exp #line 75 "..//parser.y" - { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } -#line 691 "parser.cpp" + { drv.createNode(yystack_[1].value.as < std::string > (), 2); } +#line 686 "parser.cpp" break; - case 10: // indices_list: index + case 10: // exp: "(" exp ")" #line 76 "..//parser.y" - { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } -#line 697 "parser.cpp" + { } +#line 692 "parser.cpp" break; - case 11: // indices_list: %empty + case 11: // exp: "identifier" "(" list ")" #line 77 "..//parser.y" - { yylhs.value.as < std::vector> > () = {}; } -#line 703 "parser.cpp" - break; - - case 12: // index: "number" ":" "number" ":" "number" -#line 80 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } -#line 709 "parser.cpp" - break; - - case 13: // index: ":" "number" ":" "number" -#line 81 "..//parser.y" - { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } -#line 715 "parser.cpp" + { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } +#line 698 "parser.cpp" break; - case 14: // index: "number" ":" ":" "number" -#line 82 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } -#line 721 "parser.cpp" + case 12: // exp: "identifier" "[" indices_list "]" +#line 78 "..//parser.y" + { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 704 "parser.cpp" break; - case 15: // index: "number" ":" "number" ":" -#line 83 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } -#line 727 "parser.cpp" + case 13: // exp: "identifier" +#line 79 "..//parser.y" + { drv.createNode(yystack_[0].value.as < std::string > ()); } +#line 710 "parser.cpp" break; - case 16: // index: "number" ":" "number" + case 14: // indices_list: %empty #line 84 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } -#line 733 "parser.cpp" + { yylhs.value.as < std::vector> > () = {}; } +#line 716 "parser.cpp" break; - case 17: // index: ":" ":" "number" + case 15: // indices_list: indices_list "," index #line 85 "..//parser.y" - { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } -#line 739 "parser.cpp" + { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } +#line 722 "parser.cpp" break; - case 18: // index: ":" "number" ":" + case 16: // indices_list: index #line 86 "..//parser.y" - { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } -#line 745 "parser.cpp" + { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } +#line 728 "parser.cpp" break; - case 19: // index: ":" "number" -#line 87 "..//parser.y" - { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } -#line 751 "parser.cpp" + case 17: // index: %empty +#line 90 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } +#line 734 "parser.cpp" break; - case 20: // index: "number" ":" ":" -#line 88 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } -#line 757 "parser.cpp" + case 18: // index: "number" ":" "number" ":" "number" +#line 91 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } +#line 740 "parser.cpp" break; - case 21: // index: "number" ":" -#line 89 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } -#line 763 "parser.cpp" + case 19: // index: ":" "number" ":" "number" +#line 92 "..//parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } +#line 746 "parser.cpp" break; - case 22: // index: "number" -#line 90 "..//parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } -#line 769 "parser.cpp" + case 20: // index: "number" ":" ":" "number" +#line 93 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } +#line 752 "parser.cpp" break; - case 23: // index: %empty -#line 91 "..//parser.y" - { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } -#line 775 "parser.cpp" + case 21: // index: "number" ":" "number" ":" +#line 94 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } +#line 758 "parser.cpp" break; - case 24: // exp: "number" + case 22: // index: "number" ":" "number" #line 95 "..//parser.y" - { yylhs.value.as < int > () = yystack_[0].value.as < int > (); } -#line 781 "parser.cpp" + { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } +#line 764 "parser.cpp" break; - case 25: // exp: exp OPERATOR exp + case 23: // index: ":" ":" "number" #line 96 "..//parser.y" - { drv.createNode(yystack_[1].value.as < std::string > (), 2); } -#line 787 "parser.cpp" + { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } +#line 770 "parser.cpp" break; - case 26: // exp: "identifier" "(" list ")" + case 24: // index: ":" "number" ":" #line 97 "..//parser.y" - { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } -#line 793 "parser.cpp" + { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } +#line 776 "parser.cpp" break; - case 27: // exp: "identifier" "[" indices_list "]" + case 25: // index: ":" "number" #line 98 "..//parser.y" - { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } -#line 799 "parser.cpp" + { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } +#line 782 "parser.cpp" break; - case 28: // exp: "identifier" + case 26: // index: "number" ":" ":" #line 99 "..//parser.y" - { drv.createNode(yystack_[0].value.as < std::string > ()); } -#line 805 "parser.cpp" + { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } +#line 788 "parser.cpp" break; - case 29: // exp: "(" exp ")" + case 27: // index: "number" ":" #line 100 "..//parser.y" - { } -#line 811 "parser.cpp" + { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } +#line 794 "parser.cpp" break; - case 30: // list: exp "," list -#line 104 "..//parser.y" - { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } -#line 817 "parser.cpp" + case 28: // index: "number" +#line 101 "..//parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } +#line 800 "parser.cpp" break; - case 31: // list: exp + case 29: // list: %empty #line 105 "..//parser.y" - { yylhs.value.as < int > () = 1; } -#line 823 "parser.cpp" + { yylhs.value.as < int > () = 0; } +#line 806 "parser.cpp" break; - case 32: // list: %empty + case 30: // list: exp "," list #line 106 "..//parser.y" - { yylhs.value.as < int > () = 0; } -#line 829 "parser.cpp" + { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } +#line 812 "parser.cpp" break; + case 31: // list: exp +#line 107 "..//parser.y" + { yylhs.value.as < int > () = 1; } +#line 818 "parser.cpp" + break; -#line 833 "parser.cpp" + +#line 822 "parser.cpp" default: break; @@ -1013,10 +1002,9 @@ namespace adios2 { namespace detail { { static const char *const yy_sname[] = { - "end of file", "error", "invalid token", ":=", ",", ":", "(", ")", "[", - "]", "\n", "var", "OPERATOR", "identifier", "VARNAME", "number", - "$accept", "unit", "assignments", "assignment", "indices_list", "index", - "exp", "list", YY_NULLPTR + "end of file", "error", "invalid token", "=", ",", ":", "(", ")", "[", + "]", "\n", "OPERATOR", "identifier", "VARNAME", "number", "$accept", + "lines", "assignment", "exp", "indices_list", "index", "list", YY_NULLPTR }; return yy_sname[yysymbol]; } @@ -1285,91 +1273,90 @@ namespace adios2 { namespace detail { } - const signed char parser::yypact_ninf_ = -6; + const signed char parser::yypact_ninf_ = -21; const signed char parser::yytable_ninf_ = -1; const signed char parser::yypact_[] = { - 10, 15, 27, 4, 26, 22, -6, 4, 16, -6, - 21, 12, 10, -5, 4, -4, 4, 28, 29, -6, - -6, 8, 31, 0, 30, -1, -6, 21, -4, -4, - 4, -6, 19, 34, 1, -4, -6, 5, 14, -6, - -6, 25, 32, 36, -6, -6, -6, -6, -6, 33, - -6 + 2, 9, 22, -21, 19, 10, 15, 32, 11, -8, + 9, -4, -21, 2, 9, -21, 31, 33, 13, 26, + -3, 30, 25, -21, -21, -21, -4, -4, 9, -21, + 29, 37, -2, -4, -21, 27, 28, -21, -21, 34, + 35, 39, -21, -21, -21, -21, -21, 36, -21 }; const signed char parser::yydefact_[] = { - 3, 0, 0, 0, 0, 0, 1, 0, 28, 24, - 2, 0, 3, 0, 32, 11, 0, 6, 5, 4, - 29, 31, 0, 0, 22, 0, 10, 25, 11, 11, - 32, 26, 0, 19, 21, 23, 27, 0, 0, 30, - 17, 18, 20, 16, 9, 8, 7, 13, 14, 15, - 12 + 0, 0, 13, 8, 0, 0, 3, 13, 0, 0, + 29, 14, 1, 0, 0, 10, 5, 4, 31, 0, + 0, 28, 0, 16, 2, 9, 14, 14, 29, 11, + 0, 25, 27, 17, 12, 0, 0, 30, 23, 24, + 26, 22, 15, 7, 6, 19, 20, 21, 18 }; const signed char parser::yypgoto_[] = { - -6, -6, 37, -6, 2, 7, -3, 13 + -21, 38, -21, -1, -20, 12, 18 }; const signed char parser::yydefgoto_[] = { - 0, 2, 3, 5, 25, 26, 21, 22 + 0, 4, 5, 6, 22, 23, 19 }; const signed char parser::yytable_[] = { - 10, 23, 20, 35, 13, 32, 42, 16, 36, 35, - 7, 24, 30, 27, 45, 33, 43, 8, 35, 9, - 16, 1, 14, 46, 15, 17, 18, 6, 4, 11, - 37, 38, 12, 16, 40, 34, 28, 29, 31, 41, - 47, 49, 44, 39, 0, 0, 0, 48, 50, 19 + 8, 20, 30, 40, 16, 17, 35, 36, 1, 18, + 21, 31, 41, 25, 2, 1, 3, 28, 15, 12, + 13, 7, 14, 3, 14, 9, 14, 18, 10, 33, + 11, 33, 33, 29, 34, 32, 43, 44, 10, 26, + 11, 27, 39, 38, 47, 42, 37, 0, 45, 46, + 48, 24 }; const signed char parser::yycheck_[] = { - 3, 5, 7, 4, 7, 5, 5, 12, 9, 4, - 6, 15, 4, 16, 9, 15, 15, 13, 4, 15, - 12, 11, 6, 9, 8, 13, 14, 0, 13, 3, - 28, 29, 10, 12, 15, 5, 8, 8, 7, 5, - 15, 5, 35, 30, -1, -1, -1, 15, 15, 12 + 1, 5, 5, 5, 12, 13, 26, 27, 6, 10, + 14, 14, 14, 14, 12, 6, 14, 4, 7, 0, + 10, 12, 11, 14, 11, 3, 11, 28, 6, 4, + 8, 4, 4, 7, 9, 5, 9, 9, 6, 8, + 8, 8, 5, 14, 5, 33, 28, -1, 14, 14, + 14, 13 }; const signed char parser::yystos_[] = { - 0, 11, 17, 18, 13, 19, 0, 6, 13, 15, - 22, 3, 10, 22, 6, 8, 12, 13, 14, 18, - 7, 22, 23, 5, 15, 20, 21, 22, 8, 8, - 4, 7, 5, 15, 5, 4, 9, 20, 20, 23, - 15, 5, 5, 15, 21, 9, 9, 15, 15, 5, - 15 + 0, 6, 12, 14, 16, 17, 18, 12, 18, 3, + 6, 8, 0, 10, 11, 7, 12, 13, 18, 21, + 5, 14, 19, 20, 16, 18, 8, 8, 4, 7, + 5, 14, 5, 4, 9, 19, 19, 21, 14, 5, + 5, 14, 20, 9, 9, 14, 14, 5, 14 }; const signed char parser::yyr1_[] = { - 0, 16, 17, 18, 18, 19, 19, 19, 19, 20, - 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, - 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, - 23, 23, 23 + 0, 15, 16, 16, 17, 17, 17, 17, 18, 18, + 18, 18, 18, 18, 19, 19, 19, 20, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, + 21, 21 }; const signed char parser::yyr2_[] = { - 0, 2, 2, 0, 4, 3, 3, 6, 6, 3, - 1, 0, 5, 4, 4, 4, 3, 3, 3, 2, - 3, 2, 1, 0, 1, 3, 4, 4, 1, 3, - 3, 1, 0 + 0, 2, 3, 1, 3, 3, 6, 6, 1, 3, + 3, 4, 4, 1, 0, 3, 1, 0, 5, 4, + 4, 4, 3, 3, 3, 2, 3, 2, 1, 0, + 3, 1 }; @@ -1379,10 +1366,10 @@ namespace adios2 { namespace detail { const signed char parser::yyrline_[] = { - 0, 62, 62, 65, 66, 69, 70, 71, 72, 75, - 76, 77, 80, 81, 82, 83, 84, 85, 86, 87, - 88, 89, 90, 91, 95, 96, 97, 98, 99, 100, - 104, 105, 106 + 0, 62, 62, 63, 67, 68, 69, 70, 74, 75, + 76, 77, 78, 79, 84, 85, 86, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 105, + 106, 107 }; void @@ -1415,9 +1402,9 @@ namespace adios2 { namespace detail { #line 6 "..//parser.y" } } // adios2::detail -#line 1419 "parser.cpp" +#line 1406 "parser.cpp" -#line 107 "..//parser.y" +#line 108 "..//parser.y" void diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/parser.h index 99e5a24294..b69f5d252c 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.h @@ -419,7 +419,6 @@ namespace adios2 { namespace detail { union union_type { // "number" - // exp // list char dummy1[sizeof (int)]; @@ -485,7 +484,7 @@ namespace adios2 { namespace detail { TOK_YYEOF = 0, // "end of file" TOK_YYerror = 1, // error TOK_YYUNDEF = 2, // "invalid token" - TOK_ASSIGN = 3, // ":=" + TOK_ASSIGN = 3, // "=" TOK_COMMA = 4, // "," TOK_COLON = 5, // ":" TOK_L_PAREN = 6, // "(" @@ -493,11 +492,10 @@ namespace adios2 { namespace detail { TOK_L_BRACE = 8, // "[" TOK_R_BRACE = 9, // "]" TOK_ENDL = 10, // "\n" - TOK_VAR = 11, // "var" - TOK_OPERATOR = 12, // OPERATOR - TOK_IDENTIFIER = 13, // "identifier" - TOK_VARNAME = 14, // VARNAME - TOK_INT = 15 // "number" + TOK_OPERATOR = 11, // OPERATOR + TOK_IDENTIFIER = 12, // "identifier" + TOK_VARNAME = 13, // VARNAME + TOK_INT = 14 // "number" }; /// Backward compatibility alias (Bison 3.6). typedef token_kind_type yytokentype; @@ -514,12 +512,12 @@ namespace adios2 { namespace detail { { enum symbol_kind_type { - YYNTOKENS = 16, ///< Number of tokens. + YYNTOKENS = 15, ///< Number of tokens. S_YYEMPTY = -2, S_YYEOF = 0, // "end of file" S_YYerror = 1, // error S_YYUNDEF = 2, // "invalid token" - S_ASSIGN = 3, // ":=" + S_ASSIGN = 3, // "=" S_COMMA = 4, // "," S_COLON = 5, // ":" S_L_PAREN = 6, // "(" @@ -527,19 +525,17 @@ namespace adios2 { namespace detail { S_L_BRACE = 8, // "[" S_R_BRACE = 9, // "]" S_ENDL = 10, // "\n" - S_VAR = 11, // "var" - S_OPERATOR = 12, // OPERATOR - S_IDENTIFIER = 13, // "identifier" - S_VARNAME = 14, // VARNAME - S_INT = 15, // "number" - S_YYACCEPT = 16, // $accept - S_unit = 17, // unit - S_assignments = 18, // assignments - S_assignment = 19, // assignment - S_indices_list = 20, // indices_list - S_index = 21, // index - S_exp = 22, // exp - S_list = 23 // list + S_OPERATOR = 11, // OPERATOR + S_IDENTIFIER = 12, // "identifier" + S_VARNAME = 13, // VARNAME + S_INT = 14, // "number" + S_YYACCEPT = 15, // $accept + S_lines = 16, // lines + S_assignment = 17, // assignment + S_exp = 18, // exp + S_indices_list = 19, // indices_list + S_index = 20, // index + S_list = 21 // list }; }; @@ -577,7 +573,6 @@ namespace adios2 { namespace detail { switch (this->kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.move< int > (std::move (that.value)); break; @@ -700,7 +695,6 @@ namespace adios2 { namespace detail { switch (yykind) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.template destroy< int > (); break; @@ -817,7 +811,7 @@ switch (yykind) { #if !defined _MSC_VER || defined __clang__ YY_ASSERT (tok == token::TOK_YYEOF - || (token::TOK_YYerror <= tok && tok <= token::TOK_VAR)); + || (token::TOK_YYerror <= tok && tok <= token::TOK_ENDL)); #endif } #if 201103L <= YY_CPLUSPLUS @@ -1057,21 +1051,6 @@ switch (yykind) return symbol_type (token::TOK_ENDL, l); } #endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_VAR (location_type l) - { - return symbol_type (token::TOK_VAR, std::move (l)); - } -#else - static - symbol_type - make_VAR (const location_type& l) - { - return symbol_type (token::TOK_VAR, l); - } -#endif #if 201103L <= YY_CPLUSPLUS static symbol_type @@ -1476,9 +1455,9 @@ switch (yykind) /// Constants. enum { - yylast_ = 49, ///< Last index in yytable_. - yynnts_ = 8, ///< Number of nonterminal symbols. - yyfinal_ = 6 ///< Termination state number. + yylast_ = 51, ///< Last index in yytable_. + yynnts_ = 7, ///< Number of nonterminal symbols. + yyfinal_ = 12 ///< Termination state number. }; @@ -1504,7 +1483,6 @@ switch (yykind) switch (this->kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.copy< int > (YY_MOVE (that.value)); break; @@ -1555,7 +1533,6 @@ switch (yykind) switch (this->kind ()) { case symbol_kind::S_INT: // "number" - case symbol_kind::S_exp: // exp case symbol_kind::S_list: // list value.move< int > (YY_MOVE (s.value)); break; @@ -1641,7 +1618,7 @@ switch (yykind) #line 6 "..//parser.y" } } // adios2::detail -#line 1645 "parser.h" +#line 1622 "parser.h" diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.output b/source/adios2/toolkit/derived/parser/pregen-source/parser.output index 9b5e1a36a1..d7c0f695f3 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.output +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.output @@ -1,597 +1,577 @@ -State 15 conflicts: 2 reduce/reduce -State 27 conflicts: 1 shift/reduce -State 28 conflicts: 2 reduce/reduce -State 29 conflicts: 2 reduce/reduce +State 11 conflicts: 2 reduce/reduce +State 26 conflicts: 2 reduce/reduce +State 27 conflicts: 2 reduce/reduce Grammar - 0 $accept: unit $end - - 1 unit: assignments exp - - 2 assignments: ε - 3 | "var" assignment "\n" assignments - - 4 assignment: "identifier" ":=" VARNAME - 5 | "identifier" ":=" "identifier" - 6 | "identifier" ":=" VARNAME "[" indices_list "]" - 7 | "identifier" ":=" "identifier" "[" indices_list "]" - - 8 indices_list: indices_list "," index - 9 | index - 10 | ε - - 11 index: "number" ":" "number" ":" "number" - 12 | ":" "number" ":" "number" - 13 | "number" ":" ":" "number" - 14 | "number" ":" "number" ":" - 15 | "number" ":" "number" - 16 | ":" ":" "number" - 17 | ":" "number" ":" - 18 | ":" "number" - 19 | "number" ":" ":" - 20 | "number" ":" - 21 | "number" - 22 | ε - - 23 exp: "number" - 24 | exp OPERATOR exp - 25 | "identifier" "(" list ")" - 26 | "identifier" "[" indices_list "]" - 27 | "identifier" - 28 | "(" exp ")" - - 29 list: exp "," list + 0 $accept: lines $end + + 1 lines: assignment "\n" lines + 2 | exp + + 3 assignment: "identifier" "=" VARNAME + 4 | "identifier" "=" "identifier" + 5 | "identifier" "=" VARNAME "[" indices_list "]" + 6 | "identifier" "=" "identifier" "[" indices_list "]" + + 7 exp: "number" + 8 | exp OPERATOR exp + 9 | "(" exp ")" + 10 | "identifier" "(" list ")" + 11 | "identifier" "[" indices_list "]" + 12 | "identifier" + + 13 indices_list: ε + 14 | indices_list "," index + 15 | index + + 16 index: ε + 17 | "number" ":" "number" ":" "number" + 18 | ":" "number" ":" "number" + 19 | "number" ":" ":" "number" + 20 | "number" ":" "number" ":" + 21 | "number" ":" "number" + 22 | ":" ":" "number" + 23 | ":" "number" ":" + 24 | ":" "number" + 25 | "number" ":" ":" + 26 | "number" ":" + 27 | "number" + + 28 list: ε + 29 | exp "," list 30 | exp - 31 | ε Terminals, with rules where they appear $end (0) 0 error (256) - ":=" (258) 4 5 6 7 - "," (259) 8 29 - ":" (260) 11 12 13 14 15 16 17 18 19 20 - "(" (261) 25 28 - ")" (262) 25 28 - "[" (263) 6 7 26 - "]" (264) 6 7 26 - "\n" (265) 3 - "var" (266) 3 - OPERATOR (267) 24 - "identifier" (268) 4 5 6 7 25 26 27 - VARNAME (269) 4 6 - "number" (270) 11 12 13 14 15 16 17 18 19 20 21 23 + "=" (258) 3 4 5 6 + "," (259) 14 29 + ":" (260) 17 18 19 20 21 22 23 24 25 26 + "(" (261) 9 10 + ")" (262) 9 10 + "[" (263) 5 6 11 + "]" (264) 5 6 11 + "\n" (265) 1 + OPERATOR (266) 8 + "identifier" (267) 3 4 5 6 10 11 12 + VARNAME (268) 3 5 + "number" (269) 7 17 18 19 20 21 22 23 24 25 26 27 Nonterminals, with rules where they appear - $accept (16) + $accept (15) on left: 0 - unit (17) - on left: 1 - on right: 0 - assignments (18) - on left: 2 3 - on right: 1 3 - assignment (19) - on left: 4 5 6 7 - on right: 3 - indices_list >> (20) - on left: 8 9 10 - on right: 6 7 8 26 - index > (21) - on left: 11 12 13 14 15 16 17 18 19 20 21 22 - on right: 8 9 - exp (22) - on left: 23 24 25 26 27 28 - on right: 1 24 28 29 30 - list (23) - on left: 29 30 31 - on right: 25 29 + lines (16) + on left: 1 2 + on right: 0 1 + assignment (17) + on left: 3 4 5 6 + on right: 1 + exp (18) + on left: 7 8 9 10 11 12 + on right: 2 8 9 29 30 + indices_list >> (19) + on left: 13 14 15 + on right: 5 6 11 14 + index > (20) + on left: 16 17 18 19 20 21 22 23 24 25 26 27 + on right: 14 15 + list (21) + on left: 28 29 30 + on right: 10 29 State 0 - 0 $accept: • unit $end + 0 $accept: • lines $end - "var" shift, and go to state 1 + "(" shift, and go to state 1 + "identifier" shift, and go to state 2 + "number" shift, and go to state 3 - $default reduce using rule 2 (assignments) - - unit go to state 2 - assignments go to state 3 + lines go to state 4 + assignment go to state 5 + exp go to state 6 State 1 - 3 assignments: "var" • assignment "\n" assignments + 9 exp: "(" • exp ")" - "identifier" shift, and go to state 4 + "(" shift, and go to state 1 + "identifier" shift, and go to state 7 + "number" shift, and go to state 3 - assignment go to state 5 + exp go to state 8 State 2 - 0 $accept: unit • $end + 3 assignment: "identifier" • "=" VARNAME + 4 | "identifier" • "=" "identifier" + 5 | "identifier" • "=" VARNAME "[" indices_list "]" + 6 | "identifier" • "=" "identifier" "[" indices_list "]" + 10 exp: "identifier" • "(" list ")" + 11 | "identifier" • "[" indices_list "]" + 12 | "identifier" • - $end shift, and go to state 6 + "=" shift, and go to state 9 + "(" shift, and go to state 10 + "[" shift, and go to state 11 + $default reduce using rule 12 (exp) -State 3 - 1 unit: assignments • exp +State 3 - "(" shift, and go to state 7 - "identifier" shift, and go to state 8 - "number" shift, and go to state 9 + 7 exp: "number" • - exp go to state 10 + $default reduce using rule 7 (exp) State 4 - 4 assignment: "identifier" • ":=" VARNAME - 5 | "identifier" • ":=" "identifier" - 6 | "identifier" • ":=" VARNAME "[" indices_list "]" - 7 | "identifier" • ":=" "identifier" "[" indices_list "]" + 0 $accept: lines • $end - ":=" shift, and go to state 11 + $end shift, and go to state 12 State 5 - 3 assignments: "var" assignment • "\n" assignments + 1 lines: assignment • "\n" lines - "\n" shift, and go to state 12 + "\n" shift, and go to state 13 State 6 - 0 $accept: unit $end • + 2 lines: exp • + 8 exp: exp • OPERATOR exp - $default accept + OPERATOR shift, and go to state 14 + + $default reduce using rule 2 (lines) State 7 - 28 exp: "(" • exp ")" + 10 exp: "identifier" • "(" list ")" + 11 | "identifier" • "[" indices_list "]" + 12 | "identifier" • - "(" shift, and go to state 7 - "identifier" shift, and go to state 8 - "number" shift, and go to state 9 + "(" shift, and go to state 10 + "[" shift, and go to state 11 - exp go to state 13 + $default reduce using rule 12 (exp) State 8 - 25 exp: "identifier" • "(" list ")" - 26 | "identifier" • "[" indices_list "]" - 27 | "identifier" • - - "(" shift, and go to state 14 - "[" shift, and go to state 15 + 8 exp: exp • OPERATOR exp + 9 | "(" exp • ")" - $default reduce using rule 27 (exp) + ")" shift, and go to state 15 + OPERATOR shift, and go to state 14 State 9 - 23 exp: "number" • + 3 assignment: "identifier" "=" • VARNAME + 4 | "identifier" "=" • "identifier" + 5 | "identifier" "=" • VARNAME "[" indices_list "]" + 6 | "identifier" "=" • "identifier" "[" indices_list "]" - $default reduce using rule 23 (exp) + "identifier" shift, and go to state 16 + VARNAME shift, and go to state 17 State 10 - 1 unit: assignments exp • - 24 exp: exp • OPERATOR exp + 10 exp: "identifier" "(" • list ")" - OPERATOR shift, and go to state 16 + "(" shift, and go to state 1 + "identifier" shift, and go to state 7 + "number" shift, and go to state 3 - $default reduce using rule 1 (unit) + $default reduce using rule 28 (list) + + exp go to state 18 + list go to state 19 State 11 - 4 assignment: "identifier" ":=" • VARNAME - 5 | "identifier" ":=" • "identifier" - 6 | "identifier" ":=" • VARNAME "[" indices_list "]" - 7 | "identifier" ":=" • "identifier" "[" indices_list "]" + 11 exp: "identifier" "[" • indices_list "]" - "identifier" shift, and go to state 17 - VARNAME shift, and go to state 18 + ":" shift, and go to state 20 + "number" shift, and go to state 21 + "," reduce using rule 13 (indices_list) + "," [reduce using rule 16 (index)] + "]" reduce using rule 13 (indices_list) + "]" [reduce using rule 16 (index)] + $default reduce using rule 13 (indices_list) -State 12 + indices_list go to state 22 + index go to state 23 - 3 assignments: "var" assignment "\n" • assignments - "var" shift, and go to state 1 +State 12 - $default reduce using rule 2 (assignments) + 0 $accept: lines $end • - assignments go to state 19 + $default accept State 13 - 24 exp: exp • OPERATOR exp - 28 | "(" exp • ")" + 1 lines: assignment "\n" • lines - ")" shift, and go to state 20 - OPERATOR shift, and go to state 16 + "(" shift, and go to state 1 + "identifier" shift, and go to state 2 + "number" shift, and go to state 3 + lines go to state 24 + assignment go to state 5 + exp go to state 6 -State 14 - 25 exp: "identifier" "(" • list ")" +State 14 - "(" shift, and go to state 7 - "identifier" shift, and go to state 8 - "number" shift, and go to state 9 + 8 exp: exp OPERATOR • exp - $default reduce using rule 31 (list) + "(" shift, and go to state 1 + "identifier" shift, and go to state 7 + "number" shift, and go to state 3 - exp go to state 21 - list go to state 22 + exp go to state 25 State 15 - 26 exp: "identifier" "[" • indices_list "]" + 9 exp: "(" exp ")" • - ":" shift, and go to state 23 - "number" shift, and go to state 24 - - "," reduce using rule 10 (indices_list) - "," [reduce using rule 22 (index)] - "]" reduce using rule 10 (indices_list) - "]" [reduce using rule 22 (index)] - $default reduce using rule 10 (indices_list) - - indices_list go to state 25 - index go to state 26 + $default reduce using rule 9 (exp) State 16 - 24 exp: exp OPERATOR • exp + 4 assignment: "identifier" "=" "identifier" • + 6 | "identifier" "=" "identifier" • "[" indices_list "]" - "(" shift, and go to state 7 - "identifier" shift, and go to state 8 - "number" shift, and go to state 9 + "[" shift, and go to state 26 - exp go to state 27 + $default reduce using rule 4 (assignment) State 17 - 5 assignment: "identifier" ":=" "identifier" • - 7 | "identifier" ":=" "identifier" • "[" indices_list "]" + 3 assignment: "identifier" "=" VARNAME • + 5 | "identifier" "=" VARNAME • "[" indices_list "]" - "[" shift, and go to state 28 + "[" shift, and go to state 27 - $default reduce using rule 5 (assignment) + $default reduce using rule 3 (assignment) State 18 - 4 assignment: "identifier" ":=" VARNAME • - 6 | "identifier" ":=" VARNAME • "[" indices_list "]" + 8 exp: exp • OPERATOR exp + 29 list: exp • "," list + 30 | exp • - "[" shift, and go to state 29 + "," shift, and go to state 28 + OPERATOR shift, and go to state 14 - $default reduce using rule 4 (assignment) + $default reduce using rule 30 (list) State 19 - 3 assignments: "var" assignment "\n" assignments • + 10 exp: "identifier" "(" list • ")" - $default reduce using rule 3 (assignments) + ")" shift, and go to state 29 State 20 - 28 exp: "(" exp ")" • + 18 index: ":" • "number" ":" "number" + 22 | ":" • ":" "number" + 23 | ":" • "number" ":" + 24 | ":" • "number" - $default reduce using rule 28 (exp) + ":" shift, and go to state 30 + "number" shift, and go to state 31 State 21 - 24 exp: exp • OPERATOR exp - 29 list: exp • "," list - 30 | exp • + 17 index: "number" • ":" "number" ":" "number" + 19 | "number" • ":" ":" "number" + 20 | "number" • ":" "number" ":" + 21 | "number" • ":" "number" + 25 | "number" • ":" ":" + 26 | "number" • ":" + 27 | "number" • - "," shift, and go to state 30 - OPERATOR shift, and go to state 16 + ":" shift, and go to state 32 - $default reduce using rule 30 (list) + $default reduce using rule 27 (index) State 22 - 25 exp: "identifier" "(" list • ")" + 11 exp: "identifier" "[" indices_list • "]" + 14 indices_list: indices_list • "," index - ")" shift, and go to state 31 + "," shift, and go to state 33 + "]" shift, and go to state 34 State 23 - 12 index: ":" • "number" ":" "number" - 16 | ":" • ":" "number" - 17 | ":" • "number" ":" - 18 | ":" • "number" + 15 indices_list: index • - ":" shift, and go to state 32 - "number" shift, and go to state 33 + $default reduce using rule 15 (indices_list) State 24 - 11 index: "number" • ":" "number" ":" "number" - 13 | "number" • ":" ":" "number" - 14 | "number" • ":" "number" ":" - 15 | "number" • ":" "number" - 19 | "number" • ":" ":" - 20 | "number" • ":" - 21 | "number" • - - ":" shift, and go to state 34 + 1 lines: assignment "\n" lines • - $default reduce using rule 21 (index) + $default reduce using rule 1 (lines) State 25 - 8 indices_list: indices_list • "," index - 26 exp: "identifier" "[" indices_list • "]" + 8 exp: exp • OPERATOR exp + 8 | exp OPERATOR exp • - "," shift, and go to state 35 - "]" shift, and go to state 36 + $default reduce using rule 8 (exp) State 26 - 9 indices_list: index • + 6 assignment: "identifier" "=" "identifier" "[" • indices_list "]" + + ":" shift, and go to state 20 + "number" shift, and go to state 21 + + "," reduce using rule 13 (indices_list) + "," [reduce using rule 16 (index)] + "]" reduce using rule 13 (indices_list) + "]" [reduce using rule 16 (index)] + $default reduce using rule 13 (indices_list) - $default reduce using rule 9 (indices_list) + indices_list go to state 35 + index go to state 23 State 27 - 24 exp: exp • OPERATOR exp - 24 | exp OPERATOR exp • + 5 assignment: "identifier" "=" VARNAME "[" • indices_list "]" - OPERATOR shift, and go to state 16 + ":" shift, and go to state 20 + "number" shift, and go to state 21 - OPERATOR [reduce using rule 24 (exp)] - $default reduce using rule 24 (exp) + "," reduce using rule 13 (indices_list) + "," [reduce using rule 16 (index)] + "]" reduce using rule 13 (indices_list) + "]" [reduce using rule 16 (index)] + $default reduce using rule 13 (indices_list) + + indices_list go to state 36 + index go to state 23 State 28 - 7 assignment: "identifier" ":=" "identifier" "[" • indices_list "]" + 29 list: exp "," • list - ":" shift, and go to state 23 - "number" shift, and go to state 24 + "(" shift, and go to state 1 + "identifier" shift, and go to state 7 + "number" shift, and go to state 3 - "," reduce using rule 10 (indices_list) - "," [reduce using rule 22 (index)] - "]" reduce using rule 10 (indices_list) - "]" [reduce using rule 22 (index)] - $default reduce using rule 10 (indices_list) + $default reduce using rule 28 (list) - indices_list go to state 37 - index go to state 26 + exp go to state 18 + list go to state 37 State 29 - 6 assignment: "identifier" ":=" VARNAME "[" • indices_list "]" - - ":" shift, and go to state 23 - "number" shift, and go to state 24 + 10 exp: "identifier" "(" list ")" • - "," reduce using rule 10 (indices_list) - "," [reduce using rule 22 (index)] - "]" reduce using rule 10 (indices_list) - "]" [reduce using rule 22 (index)] - $default reduce using rule 10 (indices_list) - - indices_list go to state 38 - index go to state 26 + $default reduce using rule 10 (exp) State 30 - 29 list: exp "," • list - - "(" shift, and go to state 7 - "identifier" shift, and go to state 8 - "number" shift, and go to state 9 - - $default reduce using rule 31 (list) + 22 index: ":" ":" • "number" - exp go to state 21 - list go to state 39 + "number" shift, and go to state 38 State 31 - 25 exp: "identifier" "(" list ")" • + 18 index: ":" "number" • ":" "number" + 23 | ":" "number" • ":" + 24 | ":" "number" • + + ":" shift, and go to state 39 - $default reduce using rule 25 (exp) + $default reduce using rule 24 (index) State 32 - 16 index: ":" ":" • "number" + 17 index: "number" ":" • "number" ":" "number" + 19 | "number" ":" • ":" "number" + 20 | "number" ":" • "number" ":" + 21 | "number" ":" • "number" + 25 | "number" ":" • ":" + 26 | "number" ":" • - "number" shift, and go to state 40 + ":" shift, and go to state 40 + "number" shift, and go to state 41 + + $default reduce using rule 26 (index) State 33 - 12 index: ":" "number" • ":" "number" - 17 | ":" "number" • ":" - 18 | ":" "number" • + 14 indices_list: indices_list "," • index - ":" shift, and go to state 41 + ":" shift, and go to state 20 + "number" shift, and go to state 21 - $default reduce using rule 18 (index) + $default reduce using rule 16 (index) + + index go to state 42 State 34 - 11 index: "number" ":" • "number" ":" "number" - 13 | "number" ":" • ":" "number" - 14 | "number" ":" • "number" ":" - 15 | "number" ":" • "number" - 19 | "number" ":" • ":" - 20 | "number" ":" • + 11 exp: "identifier" "[" indices_list "]" • - ":" shift, and go to state 42 - "number" shift, and go to state 43 - - $default reduce using rule 20 (index) + $default reduce using rule 11 (exp) State 35 - 8 indices_list: indices_list "," • index - - ":" shift, and go to state 23 - "number" shift, and go to state 24 + 6 assignment: "identifier" "=" "identifier" "[" indices_list • "]" + 14 indices_list: indices_list • "," index - $default reduce using rule 22 (index) - - index go to state 44 + "," shift, and go to state 33 + "]" shift, and go to state 43 State 36 - 26 exp: "identifier" "[" indices_list "]" • + 5 assignment: "identifier" "=" VARNAME "[" indices_list • "]" + 14 indices_list: indices_list • "," index - $default reduce using rule 26 (exp) + "," shift, and go to state 33 + "]" shift, and go to state 44 State 37 - 7 assignment: "identifier" ":=" "identifier" "[" indices_list • "]" - 8 indices_list: indices_list • "," index + 29 list: exp "," list • - "," shift, and go to state 35 - "]" shift, and go to state 45 + $default reduce using rule 29 (list) State 38 - 6 assignment: "identifier" ":=" VARNAME "[" indices_list • "]" - 8 indices_list: indices_list • "," index + 22 index: ":" ":" "number" • - "," shift, and go to state 35 - "]" shift, and go to state 46 + $default reduce using rule 22 (index) State 39 - 29 list: exp "," list • + 18 index: ":" "number" ":" • "number" + 23 | ":" "number" ":" • - $default reduce using rule 29 (list) + "number" shift, and go to state 45 + + $default reduce using rule 23 (index) State 40 - 16 index: ":" ":" "number" • + 19 index: "number" ":" ":" • "number" + 25 | "number" ":" ":" • - $default reduce using rule 16 (index) + "number" shift, and go to state 46 + + $default reduce using rule 25 (index) State 41 - 12 index: ":" "number" ":" • "number" - 17 | ":" "number" ":" • + 17 index: "number" ":" "number" • ":" "number" + 20 | "number" ":" "number" • ":" + 21 | "number" ":" "number" • - "number" shift, and go to state 47 + ":" shift, and go to state 47 - $default reduce using rule 17 (index) + $default reduce using rule 21 (index) State 42 - 13 index: "number" ":" ":" • "number" - 19 | "number" ":" ":" • + 14 indices_list: indices_list "," index • - "number" shift, and go to state 48 - - $default reduce using rule 19 (index) + $default reduce using rule 14 (indices_list) State 43 - 11 index: "number" ":" "number" • ":" "number" - 14 | "number" ":" "number" • ":" - 15 | "number" ":" "number" • + 6 assignment: "identifier" "=" "identifier" "[" indices_list "]" • - ":" shift, and go to state 49 - - $default reduce using rule 15 (index) + $default reduce using rule 6 (assignment) State 44 - 8 indices_list: indices_list "," index • + 5 assignment: "identifier" "=" VARNAME "[" indices_list "]" • - $default reduce using rule 8 (indices_list) + $default reduce using rule 5 (assignment) State 45 - 7 assignment: "identifier" ":=" "identifier" "[" indices_list "]" • + 18 index: ":" "number" ":" "number" • - $default reduce using rule 7 (assignment) + $default reduce using rule 18 (index) State 46 - 6 assignment: "identifier" ":=" VARNAME "[" indices_list "]" • + 19 index: "number" ":" ":" "number" • - $default reduce using rule 6 (assignment) + $default reduce using rule 19 (index) State 47 - 12 index: ":" "number" ":" "number" • - - $default reduce using rule 12 (index) - - -State 48 + 17 index: "number" ":" "number" ":" • "number" + 20 | "number" ":" "number" ":" • - 13 index: "number" ":" ":" "number" • - - $default reduce using rule 13 (index) - - -State 49 - - 11 index: "number" ":" "number" ":" • "number" - 14 | "number" ":" "number" ":" • - - "number" shift, and go to state 50 + "number" shift, and go to state 48 - $default reduce using rule 14 (index) + $default reduce using rule 20 (index) -State 50 +State 48 - 11 index: "number" ":" "number" ":" "number" • + 17 index: "number" ":" "number" ":" "number" • - $default reduce using rule 11 (index) + $default reduce using rule 17 (index) diff --git a/source/adios2/toolkit/derived/parser/pregen-source/simple-c b/source/adios2/toolkit/derived/parser/pregen-source/simple-c index 7f184fd9ca332b487293c581753f2b42006e8689..44f43e47aa64e3c741334b0696db2933052329ab 100755 GIT binary patch delta 68032 zcma&P2|!fU`#*fo9R}G4K^9SA*c4n47Zev16?Aeb_casO+)_+2muN5?bsQ(Ds~$~L zGA*+WC4y8C)4EL9(u^`op7CGDn8>W z&v8@A-5Z$`p|djmE}5}r-!WOUYEAaiC3SUm>egsUGTD*^YcsS@~2Ho}|hKsS+yEoIJMWGQJi4636(6Oy$q zNn0u9od)}AWVHdA@+MnS0+gteU4Gh9f;6qEq_ys}&{|zDW-g@y(^dh2>Q%_*zp zJdy25-dYqSs#O|7rd7vQq>)QQMWr_ia?%bLIb{p9!e=6@>tWm(1%bGWzC8$$6jHS) zINHG(?eBm>o&u^ecxFq#Yg%!P8f@ZGll6$T%4D^V1<`65iL_?5(ztDVZxQ#UkgVy0 zaxe==8q^bNgvs8TN@1~+md_ydts0mb1Op~pDQQ-B9A}cUqGz0Zw25-kv!iiGGtjK* zs>zmJt9Fba#_Vd7ElV|7KT`LfWJ=1#7^SgilK{^X@Vx=;$&*S~&tV~pS_qL^Ls_kQ z`xC)(N4@!pvcof6N%6WY_dB6Pdt2m+ChI6w9dKC5YBF4|Ib8TjlkXeJtx5{tY~GV8NpZ~+dQg|Q zrPqSDN>qJY5ea8e;XGBnK$Nr3tCPX0nB&5g7M+4xkyP$6BYB!8Nux~GE2i9Q{wBK4 zY}t3zw@RF@#k{RtY0=DZ?0r`cfvPga5FXRwYn{vV9+EQI8kuaVs)<#q*LBL!@F&>2 z%6s9hSg`U{cmzAA{23m@&M3_z+MCUVqJmYb+Xo`kP;?ah6@5|tRd}9$2R$nf{!TpV z=%R3-7ZlV~qZ>Fn+mI@2`YH90Q`B(@WLK%H3t+%nsXlhKu5O0-Bp4!;?$H5-cO#x* zA>;Nz&sHd}OkaZ(eL8!ynzm0_8~Ku)`mPcl)kf~8Q?53TROUv-C!BeYN!Ch=wyl6X zQV#&JhZ!t1PS>FSP`|1zGZM+BQ;tSWV|pbn`c1F5hy*VbN%=NyM_D6`tc$g}n+ z>)QkeHiDFML`kO0wf`Qaq)j*Z+ttc%ZHBuSzk#^ZC=jG%wDoY`Kt(YeD7kH0%115A zTW!CQ8|_k7x7#EC^?G54guBcTaR?Q*4>>>Bo?fNK>{fav=E}2nDMu2c<$%|epAtK} zKb_B{8F@-xVte`P*OXx$#>tm<6u#Y|F_S;rUU<0UbteC?O?j_#ZuqoUDRx<#(R)nR zA^8>QM;Wf4J*Z}tx@WsGG^wS$YP+%|$r|?0D@^(WWJeo&YHggaK9jFB>k=(Lx>ZT- z66yEFcIb0l_-T?-=N~5T+pgHUbm{cv4p4-Z%@yhIk(GQ5*%zt3DW=UocTPXHtTn(C zsBW()x4X3TzO>E3@%1((w(FP1+B`N=PTy3x;<3iE>~B#v42x|06%8J?pqX#e{JfI# zm{GLZZAh&({hIo{hOAZJF)J5`J?`6M1u@YaYMd6Pl=Q26vxx!(i`?<-@mlbXrAI9XorON&Z z$?}w?%C!ky<@QUJ*vEgDJ1;J5K2ayj6S9=ZNt0xsr9+Rm|nz~AEbVT`i>WlKWrwf-&dy>ihGL;{v&z4)wD|~FmJX!8Gr||I1 zcv+5`t^6{3ko@f|rR$t4^6i;Q_}nq_#+ilB%+1ot&rd77KL0Qam^D>|0drJ^$u_E5 z-8xk{ykM#9F;(gQbfSD=iZb`?k`Og7r1|Lr0h9GiC(l; zeq>VNdy9@RujYHikgBS=h07N2ll7CwIy%ie<3*=YmM%?})5j}?OWS*gjTe@y)mO(T zzb-A)UmWe=Z8uKi{cG83IdNR!^UI%<1JlO{W=yAOR%`lkwS1IvH#G9HN`Di~ydFhJ0vtQvdrK{}mW~%6JM&-?f=7nEw43*_idKTW`=tqZB3MXzc z%JP_Qh32hG+~lu1D}U{{BTooae#__bl8(x{S6j7wq@xH?iJGcq&Z}Lu%yIR;T{KIr zTGU?o`qgbs>>cVaf2g!tO zxcZdM;a^NUW%jPE^1TG5(e9L%WJ#0IGLXOVq$n z4^^M26zv|V`=UK{sdy#n^`0p`u*sphfO=97W>^^@#znD6tyTL{4QP`HyVW8xt;tET zMw_86GMg(WULRr}ifPzn-B?1iw-qLfv|MSqK>US;_i>S<9TT}kOG8T)P!;JnFbf1N z>IJp->=Ki;^gOWYC=ar^kvO1?P^R3ELcvj`{(^0(W3blL+k;ZfLOiQVea=NB)}d`R zt?B^E*h+;u(FT^fI$9#3M*y!mYY+M>h1j*7+m|jy4li;)N(5~Qt?nF~xG63cyE*6+ zA)B2CBJrqyU<>)6msxr03e-wN+OzZ2!ZyO3V1Gl)i@n8Gf?Cfi?Z@nxKae zA{LoKEW5<4K1o80VDtf@F%Kg;KBVQp)aI#Snm58TKP@jjlgWsVbh=_`QeRnFS7)YR z{w4Z}Gni#PMeRZ<7`FOgXib{?kqN)Al#lW zo}mteB5IX;bY;4__@kN&wD(umsCAG7|E!dE1(#bcwpsRyGu$eqCP>_&~#LG2t0_tEQ z(-oLUrR&s~&;aS6wcQ!)+e`Nd?jk`qV-xsL)rhP%YEU(S=n^NILlu^h z*ejKj3tq%(vxw<@#W9-qakv(06K<;4V~B_aQ&yC=TvR@LH@?Xx4NHq^bx#F_D!p1+ zH$Ot@Q4lYWtx#qZ^fBySLayRu$(F6E2cne^3S#8TG0KI4q~2Q>kw|vFb4}hOS{T`5 z(m9UOY@^PrEgK?r+2_j;V5!6BYLjSX=)NF%OmyLs`}Q;05~(yR+$g(8D*Fo)PWn zJ}W_0!uv-k?TY;ZU({4plPa;$DtJwKw798f(I`4?NdsqMK#*c79?@*tP7x_uP##ws zxjd*)Z7r1FiXW4`!j!a;S5B9_<+t!v;V)KM73!bOl+_;& zl9z=lXFrVd&e);VMD3cdG&)ett|;n(aqL^A@4+$htY*sAgQq9@HbvO6cvHPL3I|lI zKydb*rK)dk5Qu6=eW?*0YeYI;T0WExxg7O<=v2?1@-gNXb;-uUibD&TJmQDeF%(Z`mhL_$>PRhhC08P*X@3qKkbiPzi99>^1SO0p!N%>bL6V@v^Cxg2M*Rvm2<53uFOFxc&QH36abG%V# zh#{)!NVV<}R<3?R>T-{z(&?&VSR1C)oE)a>n^woO_p&xJ;NHC~nx!c(oEl<|Oe51n zHbYklbmc?W9#i}g^+`|E$gv+F0y-cKWL*(4VpV&9?vSZg2a7Qo3eekXb3|Q82CM&3 z=;A}F)us+^wIhw6xyLdm9@VZ4W&EcXJ00mOMCz}IS|=W1@Y5W!h7H9%1>ag`{K zmNb*O9v#1__Zk|<=@R*@kFvfbg;f{+dYa2#n|nALSzLPWoC%S~_9(14bCCJIh2auj zh=cMp<@yh;?d+I9gNs9HXv9*Go z1<0Ghud2ZsFA5c=x(apmk1kri`nU4M*_eReHFk_3bly;_E|(O~FPqB?n9}OYMEUo- z%D6Arwf+iMkZa;`?9Xb|4o?fORA+nCs)mJ%;oKwam@@8Ms(Wr1swmF;`zu$@Ej9Q} z7q+PZRJG3n<*Bb)$j@gg>%JN!XAMxk{whPZ-BWs;-_R(~4;SRjrOLVUW8_KyDDA&~ zo&Btw`?|G!Xo@0#(?d2-QF?!qAU`%mnGbLyP1*6y>5gOm7IVJXM0PuFScUb4r2c~A zHiV+qbmV7A4999H4f5LNk?%-gp@qfYZf3IW@4{i<=@>h%jQakR++%X2e+#C?<~EcB@@s4jFfVfJrI&x_~f(Z4Cdmm=kjOO$Sxy2wGd zl?9hFW72OrJv(nA&pfrRTBYv)S}3VfyFH`mf3(Yc7b_cn9O^amy5u;BQ^Na2D~&JD z4p^{QaJt&)UaexkoFu<~OF4GAjcmK6+`QaWH|>_Bv>O@b8T%{Qt5kng60da7y>nAi zE{{wq+;XKQllNU$j{Njdz^sK(C%PH&*<$PJlrLv?Q%?UJZexP>1wV;(y0F%g@a_>NS z8z5AF3>dguX@zK+lnO)yq|k0AoBkC|>vjUxCg$VnZX(g?KyJAQ+M5QmX2(deB_1+ zIJc)sGOTO@_iX9cton{ZVH?t=Z-cz1MdOdwV<~gk&1CpsNG0Z&smGz?JvU`XP4K|3 z4ifCmH2!Pqj>7!I>K@Z8bv2>pV1p%s7;XC8;S`Yc zYMVX_IjDCC|A@+vur>WGYJMKx#uFz6!8YW)DIV>j|8tmzSu3s4cXCiGL{zDEO@XmN z+G@$5zLl#sHmp95u7hSX3yj_ODix=?t-y?0hhWz_^ii<&SE(Qz`wlsZ_f+9=Hd;#m z9HA=IS5;Dnc3X!`%@Uzp(4WxgD;#u44AwBS1jZX8<3+ACQ)zi^NJQPwkpBZ$ENKJx zS3`yVzk$XAK2v!KJk5w_Z9UH%jpqd?&;4tUN4Wh29z#7(?PEeupp$3mua8IMUIEVr z50|Yhjb}4Ng{|A*IZZrG>v{fuROo5pK9?uZM1>IRzxVw zCdbw0xbn2Ftg)+ak$1!0mEJc)%wqeth7i47W*U>3E}EHG%}fq$Wvrz`$;|i%%n%A) z@3_HVGWeVP4e|C&@EYPR83f`SKp;)lYC~hNG?vu7A2px6s1BrD)hpd@wlItAC93rn zy|dPHu!Il-sI?h+NYMTd?wH7(_nVRf&RP@dL3e0>2zQK{I~uSPvVl9bmo#_0oyyfo zmzC<9&9xnMPx9wCH>W=z4}w3xKmz`JjXeDE(ELdyfBYWshfojtQwt3IsU{HT0Cqw) z@F&^fkH1s7`XL1@!%egqSyML=Vu;JB2y!Y7VuurHv<;`;i1Ej2kAvn4%X>(1htHBo zc4&EMwIqvdlDk%e0+iIgI3siPl%!d|Lxa8aIC0rG3UVNZWsos=W1FjqmkNdUjl`y= zX>=l&)|-Wvq+0+0;-}G@r6|i^c~wpBS(!?QS$p-u45OzABSa zF|<7Yh`5w@R}&^>14?M(rv&g_3~+#^TJ_jvW%=zW^H{>iAJ0{p)v^*M*80v9oZ5t> ze?$`-D1h7X+$E`)35P=-Ls&bFmf)b_PPfry)%Vu0cu0YGJVhzUOXI=rhX&r;g68`> zfZ1eoJ6@TJ+ap5dRgH31fS@l0@Hu0$J>p@~`Tj&jtb11HYRucIJk?HKiw%?h9U#;K z#2aI|E&H1KC58;EB}c?ipGn-9U2{tbfeAB)w3u!BB}B+AN59fPrSVkTgb>XL|J zhY!Jga53ntHif2j*Lq2P5!H{ZXdp5{;sRLhwp3u)YbJyV6FI`yDOeI`S)HtH)V5w z<*7fz%;~|1s#U+ZKecblJOK1vhr^?PgTroc7+1(BVz7<6V>)t4*WnL!=S9Nep%|-v zAyF#z$s~$T%_by>Lt7!>E97!(81>2LmlLTny%sYnv2^Rt21+I!-5P=>Tgt6;vXKQF zKk3w8=|L!~{(HjZrkn$)cdYCd9Gi=c5rj&Gkp6nQGW1Rp-@Da>6n=f0t}M6{liU^e zQJ`NnK#>5KD}d%_~ZuI4uFk_m8o%5 zMGPP+d8zIXP<;Ms_T+bID=r?Q zP10z20JN^l!#4e|A@YE4mGAyakn6rteE-f;ZvCCERQ}yYnetD%()FJ<%IAP@0QS9` zu7uoeqwEJ<4H$JVUHKF6rF(%&(!GiD-(kvzd+nq8eT!=g6%tjdRcGVa78{ff<<^P= zSi(u_`frsh_gV)1gY8Fda+JaH5s=!HbL<<%c)z8$?^Q_Hv53q1Mj3WLB(@1UvNoq+ z;KnMkBK;uE2p=~>ZS6su;-C|p_WSWIR(*vDApIat8Zq@t+6AJ?sL|gjU)-M{mwc%t z)-~~2b5>jp+JRVkT^sqx66M#r#3s1%Bz0M&)1Dps^k+AAV3B^~&xz`ks29JGq&$U0 zB1t64@Qtw{_XWOyf&IXj4)#7S_7%@;w6i2b_XpT}3U==>C;O|P^H&&a?{^yhp+jI{ zUZI{{%)epmP_u7((CBv;9sC$_=zH4j&mQ_Od+>cSiR9~P19Z~^p3{*qwj#vd{@TC2-9c=cx0{h|=xrX@ANIDn=IxkW z4%&ZvTLJ37y-oZNeTN><6U^7Uv7Tvf(hU@w?_L4K^@xQ4wSnGDC~>Bs-=HyN3lQ|2 z0FF7-7PP(_H|SYVhfP?BsK1HDsXk2;NEd+S_?{R{v|})RvPNs%jgQi^1W%?Fze(on z^lW(ICfu8VKU@HkOqC6m*66<&G`9muA2>H(W6MnDe(o&TW2jaf##0-y;FcJ?swBf| zoYW9&j7EzUfVSqeKGKIL^O^4K-8L6~gx5^07733h>!uDlrp^5$=!S$%-%|kJl&-u_ zBi6}N(u%Ar&u+w$8ok^FQ`G6#vY7hUXZEz05tWRs`>#(e-g6Ld`bXnrX_GR{W2cg z#59BROyB20(N2+0L5{ZJR^Kw=Re0;g`Q;{SNC=H^LY%}sW5 zIrHa5*sVp_)bs|%Q~XG#H!wBhF-|$gEMF6_2v1W1g2DuF!*a}I#0=CLMKt*UR3tb1 zGIDg6t1|rpunOeFFZ3%4pWI+n*rg2o6 zVy##`+w@VIV6;;(cZo;++<2;*FYsbb%r`ob=RvgsxK+^Q^0wE5j_GLdpl2MvubO%1cmnDX% zi4E0$ixSjcNaWl7;KpHJ=4&n&IQ>2VIWh)X z8vlp{YUtLJyNaSd4nRaBLMwX+5acO903ZXMWsM0?YN;aYaU_(x?Xt?jkjkz{!9>yj?orH z$3(nS*aMum+luJ?-j;et^D#IZe;-SHnEO~GR1m0iI}Ta+l=1&T4(Oz-g|0$-`mYRlUNFsr=n94`rAN7z)pERYS6i@xNa z1hQx4j4%0sCanF~ig7VRlCe^=lMQVQv$0hL-cL0pl1- zAbuPtBAblJuEgdFk=>{fHW6?{R*lCVt7ft|2u;ZXLG{1}4DCK%bTXv2*CWse@us)5_4x!5URfr)vl+EIyp{xgs6!VqyGxQ`QtipGO$WW^?$eFqXuo z^Fv`QLw>)EA8yVce!`C%4jH{mO+#z3R~wCH!V<78r>2|7e^QV0?1ip>_L>do^bX zjU4xPdGF?|zkIQnuLja!5ri}Wd|w8j zb+M#wI_U7x;O$sDq+@-##E2uLl1jd#NgG!9l4|;w zHgvvhteAZ2?;2gH(Myz z__teQG;M!;q6LbyX@UBeHn_Fm{RiB-a=n3D9}5jh(=wcg%7l!{yO)JWFtEJYC2Y7fJPtiCLQ&c{Rx3 z=tqG1I6wC*&x>TM#E!SeklSn0e>AN30%LCWZC~CxiZu({j7>ax=_>;Gwu9;e{pnJ@ z@c~_`o#egy_=YHUH00BZ;Ij@esxkX0gLO6@d`=z3=S8zlzV`jV(QPHW@A)73yV2~u zL_foZ@&-{zg;Dh4*&h=~nlFHF3m84nova;sUmFjW z-9uijMj3~6CTpY00Upo?llrvp_@!7j#w~iJV^}*lo==$-?hizE(X%8F4=y zgE&9jhJ{CUZNT@UlW+FF`R=_@uWzE0FY(`eM;q|PJNf<~q|5Gm+gJ!c*Ooo!zX}Y_ zk-UmV@@ehxXvvM&`HSsXS9#a#{6ss}g4wv*4pa8iuhUrFgf~xM0hqJeC$J7YGXX1T z&Nn5nVS@+lg%N9InGs=9)2JYB`9FhDj#AZouM>jqdoJ-WqYFTd1dF&>v@1rNDR7L3 zMhxbi+GFALET7yS+teh8x*n&%aUdzigG@;S4nxaIYMysAq^f3M9=E1nfFU}Rtjf*4 zU@+MIiE7u!f*r`?HI8yKXBlKtSq0O_)y~l8szp00n6)QK(6x38zH(|(KaCAud|L)D z>L}9UlEgt}MXEZ2SW&hoZ67jEbu6=zhCrc==D zH6|-xpU9d9jieQdO+4$4TRJl_AE+0{^3p`sJZSkYr|}#$lJYiv^;v$V0}JB14lKT< z@iiEo0HZjUe&Bhj71zpPa}6pU^z2zayaUUY?|ngny<$>!LS_lNjgWCV+3?4mSNro$ z9a+5m(@y?GN328o@s~TYIC=a9eyk(g?rG3&yr&)Jb2_mW{W}@fccA)B#WKRKpMlUD z%G^8*Wkc@cVA&E}Px1yyoF3KH5Ef^_xvE2#TEqi6vo7u@FafKtY)Zl&WG7|adAlTLl>K7(imogupmQV%ml|>4j;lRX z{bmPWoWy#&#}MxlelUqeux0$)BrI8f$>;Zz7*<0(tP2~{^2hCvv|4J>9yM?fT14JZ zhEo(D$AM@cBVW)9!`bWGc|jLkI`ayXTv%UARHW67wK#Bop+(s^`@!$76wE;b;Dq@K5GCg*D}0B(nhbI5J@3SE0FC2d9`boHktX_ECB2g>9S-XQA@_9lT%+ z3zUPTqNS*Q%n-?rfY^kCsbd*fn)-g2l{k8XB) zJAil{SgQ*wg6qJVU0C!47jM>Pv25qh_GF>2lLEc=yGQ^@wL5J*zk`xI;kZ@^>9`OEwn_KEg~tCeWM^x z`t!cSfW1^8z9+*D&7UJ*bHA||J>)%&2qsJwTq_!IWf2$s&dAvZYy*bEb()rFm?;wn zUaIiQGP6N_C@<=BVT04-eDXMgi-Ba`E=^=?0};v#kuW0rZ+|LkA}ke9gzTll&0WaXRQZbT%)9kt zN#=eHI0rP~>_MDys6ovX-}+i<{aPHGPz8m*Zwj9*{tf)4yzuvxJZGh=$=_;J%^4-3 z#2#HlgahIN`MN=y3HB0VzwATaHZh|L0=bcp&qJW*kk7-8-J!D|SLAh?V^RahC@&oQ zbG_5CtH(%-tyGwuis`RND06F24}tg*j?@_H z>miWkgnS1!9vm~OAE-hn&AQsaIORnZTDhuFKvkGc`X26qq6*gqqvgC%!pEdD!|>}b zIIF*zWdFJ9>_7Nn80ohckxmRAf_&()h^r?=_Y!t*z{Q$o-eT}D3+nC$)HjKW zf#9K99@i=nDkjPnntxToKaG|0qLPhWj^>b~BT1d3l0t{QNZ>Es5*{{&9Xzc@oE?aB zqL=79Q=CXYARk&tac|+9SV(O}FAz6iETRus?HQQX#Z8u#EwOjO^eXV!%3y^rVXd!r z5)zj3JACp`7B;h-+{V=Jp`l9})QIxh2I!`&Rbip=-6|YiKRpW;@3NBVlcpYAk{V zpD#4653TDG5Z7gQJFkX-xjPA1EqSEOu})|ubQB2`PUg-|a$F=eHnB?A?Ax^myfBqF zbfZeswgxz7i&9>Af5JwVZ~!SpY{NXPLp@BqIE@+185EI9%S-_3+)hU}3JD6CV6bf@ z26bzwGi0|gIagW+14*Asi^-KstJgFXS#*8kLf0o2lif~qRYq`Ns^DHn;OJn}=&)xm zA|W-Jg15fG0)Pe~H~6PswDFSzSlFna*FuAwJf1P z);NYQ%8U5S6mmsE!1__8#SPXRUE4#rXD5t0;34;7UG5Q=8aIsm+kigj^ug7BKM78Y zM+4)O7sjuxt{1=y&G3L4wY!Mfd)#XXs#PR7iUf(=yNxl?;ocqE_1Nu%Q8&PR!{|Lt zVxl35OU(*`cNfuc4(}>0mw~2FrKQ@Db6GZO4%fn)8vel$=5KB(v{8$xU`FR5X0hxI(o7SxTH6GsA8%;-6wve`gW4Kqm(Xuf$)cluC@(^^ca`)c^r7mg+N86WgGbEQ)$_ZoWo*1 zvWPIzV37!FuZJu??y^YC>Ljvw65`=_W} zO*9|YkA=D?Q{4CRnIl+#n0jvn3w~_i^V&gkEYv%LZBKf8Gld8TT1`RLYC*;G@M-eQ-n`=Y`q{>0O-lX=gul7G)DhUg~Q8)<~8Rh*Q%+ zq}O#$_2hPbZ6reGvz<2@g?qMFdCDjj)ofsnu(77zhPL3cS=R7nU`X}V7;@?vHd4O6 zk{33isrrDcVN+>C;)fUN>UiWx*2V8JoJ}IIsdR|c=`1&nX0zNQNN_4&KbnQd9K{wI zm#Cm8pLdR+4uLnm1tRnZer7al?z<8N7#EA}WBl*YEXw@^gw+{5Y7A>*{OCEYAtEIx zbo6?A(nz5m4e=s>Y7A@U<_RU_Sa)A153US#6#rrji%Hp^Ekd%SL5(Tz#x7vM{@pv!f2VfaSiJNQan-ISl|>TcuVmQ^)o zTsk#%b#3uTRtJ0;9(xMK(_+K$fS48EDL6{~2j3@d;Nkk(y1HBV?!H-9H||zloe!So ze-YmhJn+8_-zYq+zX#v(cvwFR-%s&%Jr2|G4#-<{^zOK^$?uJ4y&~wGLLH9q(yD`Q z&-T~y+J3J$A3uRT#;knr1lARgZ(N$d()?o(7UwNEm2Saxd7NExJ@ybWkxi8I-{sFu zWRWbJ=TBr|YzjX(k##Z0V@mkXyJFZ?swnH5)n!5uzY@g{T;duDF7b%=6iuNP&I!ENBsQh>9y&CzC+(+=huya; zF02FYxR6vg@H#GS+%3cpa(43*li29qaT0o)n4ex&Z= z^QYjkp06geu*3;C<`LWK^#6E=m}xP5^3__uTJ+*X9ytZ?U;T4r6#rxj8{{?fZF)!p zs}D)JKC&$zIFh!I^u%;uBMuoptD;1x@QPovG09X7JCMglKp(xG`TdotZn> zv}$W&E2+>>EahKflX>zC)>8gHpJ&WqW<1GMJ%fcZL-AiTn31`!!@3RQbi_;+;`jIh zC_@kKPJL|@Pn*d)veW#TnJm$O)({gg^|$kwdOw)S!h<`3uSfcM!@5w4#8muP*REf* zmj5ynSD=;aXR)>kc0@pZ96nW~*Wnj$SW?&Qsb~K5LACe!q**N9y$i|c`3tjHVz@iy zKbtT7LPM!bp3+?OA{R^fg;}g!Oc_=z>Pi<+?scZNCN_G{gXYv3D{nU&yO9Kv`Kz@qt z!t-Up^UylAocEf?rka;x$Vc}qsS#@$yMD2=jBbppN&mdF+(s*JbC#QFI>I<*7!uoBqI2h7h&mbh^~8!ul<=g-b(ZP_CJ=6pQa8}%gd z>Dz4Lx=a?&%6Yp?)|b7?Gc#G6m_-=9)mx~i=!LYnuuXRq=oblun8y!ivi58*zmbWK z*PDARz{+(&aU9;e%O+pP0>V({)7Uzs)--h#ZhZS5a$)fEHF0`a`7CVoATO+ywyfLK zz!#^962_O0h#2l9)~b~*N&!*a`1+?==fq`{KQY6hLd~sUYNm^E3K8GYh-F4ZMSY$B z_B4x%ZaaA3ZgiE$f>4Hs894wT%19 zQ6s1#Zihc*g8QIGBkm`7%_0`%W3R^~@{lZcTIO4df6l_=uDZUHB;_mrNI8b{@k=n6 zef1&MGGY)_dN(%m&z3OnpwG8D&$-1zGpK^PeiOg3gzYqJEp)PLKWfVBk-$$cWlaW* z7w_u9;G0{Xie6Vu3qlOU>W7$&Brtgq8+rUPmTXv#7Z5m? z7HRY@p`O|N*JaEg=WO8jm$7Z^559Fd9)z031D<6+uosJOJyz$DP17Fer zkI~)v%Aau>qPhmopxLRJY3eX)uVZQR;{E@RSN>$pMvKIqD_;B@D`uS@8$&kenNU^y z)P^QYoLDhlmdkmv=ulMg2ACXJPpZ3n0E)D_rV{>f*oV7anlFTT2h z&1Q0|b;VLs>Nz6@#P>~ z+kN`-)KzR$?9V%~{`)_lUp=sj<@oQU_H#8v=QZN_Q+{VP>)Cn(U4izb?bJi|{pXnm{a(4Al2}~E>6w`gi}^2`*{@+c zQk*>zSAB!tVb9_>x3F_^(W2r{US=~HYg*iK8yms6em@)>u$Ohx$yxW6lvAyBqX1{0 zijotv`02fDi233oYU_W$sVNc*6X&X{1mo&)wXy@Yja{i4^rohNx@j4Zs#PDl`#?(o z+^#9uM+%W|_@<^W9Ng-y_r#UxdQ%gB`7O4Nb>ywyX3u-~`#^~9QTIO0-+!C6ZP~L} zaA(k{puJ15+?sv}gUE3;l1R4fa@EwCyT8M>Ku7*NIDzQM&%MK5XB~^P-^Bw@@|rn( zQvur@cypennx4&|_aymtl9YExbZ-AsXQ~E%BaF9{<4^^wD!f-JsL**W)4R(DI7{lu z&f--)yE@aWdYXB*hbTtkcC-1-eXNNR6x>|?tP|Jmz&o%Soo)8y>;hr3L_ISX8RzSt zHaw;I?R2D|gX`*{3$EM;oEVO=@EcEo%sn==zVh_v00gPG7UL>)MuK>2RK^H0;e2b< zPp*P^Yt(?&qH#7ualU#&(C|VoD_)<2cYE0pL9DM40}P+^vUu#U)Gsv!dz?PrOyt(> zta+E8UA~go7L0rF4^8Q8oDysL`$FS$M511@u^mRgt0NP*=L@V;TH z0hjJ|Sjl*uZ_j63=5O+@ud-is-rMgh$I9&TTf2DSPW)i#yLUNzjkO+k^Ih`BLTfe{ z!3(shk7_?3#%()+#(G3)>uf0E`Hp04*=y9Z$kgB^TvQ+W10mvVm!K4&ZTQO9@c8PW z1Z}*CNucqfo!1v}TEE#kmFsq~d9rsqzHk?tAU`*bSM6f^jVH!Z@bKSpI`ZJiF}E$> zxto1TKV0dviLKRL+Ve-jqMuQ>s8**rSWXF+(Sqd^v7C3YOm?tfzYi@VSRFrA$ilqbBN1uw ztZK1wKO4k&oBizNm{vGl0$&N1z;0r!a;FB-5FS93t3h@A!(w(QFoX`c8gh=l%h!~! zPx;1T)>!U;kMAi)a997$pDAHRKIQh7wVsr636}gl>!vguT zQp`C+KjYt*Vp)@2ys3;u%dC%1!qz(>g&_>Z-s?R2{byM!c~6g-l5p|5mu$0b_9~ahgMYs$<_leWLrWQvEadPi4G4dzIlu- zcbEO~GmevZ)^Zs?a*`Fw9{q|JpJE@$a#||y{u#RvR@=zgt=@lN8hf-iPpo2l@FdgM zRhXq$@XcrNcx zW6v_X`R{m1s*AlV()%KnS`$VVshddMMd~3^FOm9))K8@TA`K8}6OjgsG*qNvB5f|x zaFH5C8YR*gvj8nc8Yj}$B5fWE0k&YJWSdoqw>Ej}OLZlfYog&g{BAp@9nIfGn(zzm? zC(=xjJ}uHkB3&%fC9Uzk>blrvqVTLppA%`0NS_z!N|CM-=^Bx)73n&Wz97;(k-j9- z4IMl~VhX7t8^%1F`Nc}|`Akrox4HjvrNW(VQKTI;*3P2PMWo3h?Jm-uBJEXt<1BlU@t@A& zFsUQo`W2hqu8y^pFsH=^9@I%GfuHN7QGqo&=>_~w5&0u>*g7|7{M%gg@vWc-dXr-iY$0jRFh3rJp=}kpI&otjb&3sFOS_1WjSJ*Kh>6TaEmp;;cpZ6G0`~AXRGDv6q0$(#om;K&g#ha^{ zg$-EmCrRu5^n3lJ4SrUv!d@}7s4_?g43t0W-{KE{soJ0NHH}+r3y@X?;56p>K%YMY zB_%NIg(lMez|`GMq+5Z-(=M@>n0e(O_OXY4s|Wkq<1e=tW%h~R3AYLZ`ztW1Fi2O{ zr1Oa&-JeauE(Ymd4<^jj;Lg<{x?Le*e}?D|g%V~()1=SBbQMjLehSm&ghk#9)17Wc zc%^yL#TL5r&6Do5(7n_ma(%e&N;u(nM1+1Cp|cq&Uu87++!?9+Hj)bYQAwMkb>BpV zy%Vjw72O$_w_*a%#^}moaKc?2>+?Z3b~Lsn>J=M>Y+1|o0bn`aO^+H>chduPyW6)6 zu7B3E6Y8-g#S?FIJ=E)Ms?;z2dX=TIJ!y|i(#mw7j|ND`(vLIX&khJ9@f!oSG9cGJ zVw34FB+9s@Cap0R`(0u0;jZ-0tS?`9kwx?Ge`4eK@}F7JBTG_@3uismp?&83S@RYx zY`?_IxYYO{YN^+<6tGNk^0a$u{?pUjFPUI$i+|m_Cr$L4oMJQ@xm9H&rcN`?nwOci zsJoXmeEPzyxr@3RC8^KgNBWGA9(gn^eXO*2`qV}9pOzk-KW#clUXn3x^4wXI7j`#B zNm21sTs-;dd6S<4F{-{`oHu`wamM_tdDDo6C)TjI;%hbR3FemmXxiZ7Ay-+R?42UD zmE!Ps3@1nv`LDmSwyoyQnm2u+GC2K+flH&}80 z3v$#*t5+~W@PE{Zulb!lj-`|M@H4;bTAHucIf|0(8GJR+%V6}r<9YY0?0GdJ(l_j0 zc+;y_uim}ud9_9C{kvD2HNSc_D!LU=SFgrgbqczmuLpkZf?%}p!}#E(cZ-mu=90hc z>F3wNTWZ>@v5zE$hlGX&8ydL>HVF#2+VX0h`I=9Fd5oK)C)+@}rS*w=qTgOW65)$cFhU>%hdcBWtSTlDo zKYV=L{oEQ!UOwJ_-a7B*?rt7#ZjC(ko}TU=9v*r>ePr`GF!^E`(%|Fn13TO%DsB^?w6L{f8e0OLmqu>aG{SaW70{83UbyciLumZ|WDokQ&Lp)%p= z53A-IB?$jYFb*z#JU<90K(3AxUS6-V>DqEa)vsG2b&OqYv7zGcq}SB`FQi z*iVv10_LYn(lkJSlO!!7I^aq`X^13k04xC91(^C6euf2@i38f>fH@;1={#WVDC}zh ztH$8ZuL2fKfa5>FQ4H~I0Slf$gaE6}QzU6HGDC4dngN(G2O$EieF`B0%)uev20(w@ zFx&;0`HUpJ5179U1_3jc!ysTPCIuBx!VQ``faQQ5)iCrt{?;sD&MH(CaHtjb0R7jY zf`I0s>m}(~WKv&(A;5x-Xmh}v&5~3On3pd}ReknJOs=+AxVz| z8b6h!xq$ws;V5AF8A)0PD19kO+W=Dm-v%uB3T;j0^OAH5uM|YXKJl7DO{?rI`@1OxggL+J;HH0ILAs z2du`+T#f-6@ur@$fVF^^sf?E#-JvpG;N)=yP4NV3^%D$DLvsL@&xO-~ne#!T@?z*E z`cmixl$Jp+p#O5T|5;>=&q6U^bvBc30}e%0Jbp&`c_xJdCaz>s9N^GZOiBjyUyV11 z09FBxCAf}BGXXQ~Oj-h1@Dh{O0p@RlL4uoM5U>gdc4rB`410j(Thacvkx6`&Np30> zW2M^!umCWI%5T6BU_Rhjz}mN%G?(ZFh#0|rs2RciFa(%$2!;SNOPO>Yuoh4S%sb4a zyMW~%p<*?t$SG6|Fz-{;G!7YK6>0|Pe+C8ts{zLXW`2&E0qW3qe56En$_?SeCkKBJ zy1)&WtX^W(dP%MY%)`X!?;$a)CZrrMiIoHTdrQn8)7DTQi5Yz{xZyk003O^FD!@0> z+!zE5rx{J401&GIRuu#$O#Asba;XL^z;K!$289?-tD8$K)rc1X8lfZ-h9V&!14FGK z*9tHW23vz4Um87!wv|{d&J9x&pg#eZa(nP6f`)_CoK6xmmv@FxlEgAGbXIi%6NXL< zpDZyMMv`H?JD7Vw2nYXp_|~RK%parW(7td8FteY;hT?`?ewxH`20)hyIxt$+0!o8G zAA|@EhRz}2$9)%R7%DbQl8nPq9)a;cbtF8*FzG)|Vi_17hfahu8In|x0R>aRI0Fi2 zAVN>ViCMtUf}y$a{wX*&AI@chKNE5b;Kw1Tb+C3}MtvT@F1MEsf8? z4o1h?9Ozqt@jovYh?PLBf`Zi;hpZ4-3uuFY9Z|8v$BZCcLHMI5slh0RfG-4mfKn)~pisuj2{uI;BV~Rw#)cYk zDH<88Hsbm>Mln{4p)fI)vBXwT5C`Enw_; zPGKwuqh7%bl;_~Oo(uXsD4z!>G5Tf9hclVblL>tbP{u1VYo7-HLO8t$e2dILJOjZc z5XA6Uz7zxui`B~^h*2@)S$GMEk&#ueKrJvLrskqXtKp25u>u2<)@A^Zj) zM!(cOjOAgp%fU!jy&t@VP*8}dybqZo7%B#D37kIyLq~weNLT$4YW*=n{xJ+y09K%~ zfH{?rISw886yK?1s(a`X{6%~8MhU%xU=H;Tg2i{-~_v$WE zu+;%yaljo8*x$kTs-wKu0gD{4)B%q<;3)_E+yTFHz>5xeT|l$HbX#N+QJV)p&gczw zL?qJz-N|3nxRImgdB1BF_-t`Y`+U#r%zYI(zF2vwVlHi3`OMx5zbU0PNi`y+wAybwHA`WZsVSlnUyq z*lkJ$^~jX=)K{_j4OA?@A;mOOu^Nq4%tPr*O7)tk7`5dZmQ%`d zsMt@GCMPLx+@&NHS1(z`JxS?xN=~}gFe~^=zx+&QcotfQqX~m!egay0%ks$0=pe<>)r0tcU283#EP?RNTG} zUKRI%Q^gih%6eGEs&`beeUzqlQn7?I6$?@7`G|_O>!M;!x~f?7ZYtKMyNcO*(h@$Z zVwGJgR-%uJS^BEj4oVaH(HeVP#ZvlH{U@lsCsphcrFBoK*xLhCY|=nl+fP$_&!|}G zXK4Yw^y6$gEtOlvs%B85l*SHHu_rTWsVL=V(dwpDd5DUAOUd(`irYiiwV!fSEb)02 z_ulig2`Cl3Kn>=q*fL62hpE`?;WU_h75l7!1~f*+I*wCu%_dO0lp1&`)~90e6IIM> zpF|x|n))&=?PMC!6ct-Fl`6kNYvfhx@P>*Fnnv61O&Y*kDn_paVvqP~K$M2f zP_YY?@@LYvpQU2QDYcnR1EZ8MN5wi*N_?9(AEjIGP#f>j8l6kqpVI5|lsA_AzKZ=o zY4&^->-qr=fKqNi#a#%fSj7b@_8z4g3ss!`pUl!Ob~KLusaG%_zooxhIPaKtUaL!o zs)|cjcj$PHte|67%gr7(q(GI(&mNs$plVoDbcGQ(t`%sJl}6PQnms0)H6$PHGM<_`7k3%CyKUMx9d> z8x9#QPHPix2MLc>hl0=TlmBE%=#H>a)F z{FdqINosYeoV2up-hGqP)s@l~i|>Tlzz%6RC89mmB>FjLg}?ZFtzSx0Emyzv0<|*1 zVhM&gBC>@mIgMW;TA%p9R8N&uOi-Xv}EygO;NC|1^gE zpygVnLDfXCgh|1$5C%HWEjS+WIt5YHnqIZ@wqvry>rSbGdt%~OR z(HM16Yfx!*?M~`q?au0hI+?jN)@^lYlvj-4MXghU|BBheWwWMpq2Al*b%{2Mf2;A_ zC2eSYl#4BaOUB7dTJw~^53JB8UX>C4se(M=vX+#drsm$4Og}%lj|NA1w3;rOv73z! zmuUt2KQq!VYj!QT&zN{w>sT_xn?ps7J(soWCBqS3zTU=+ceJX8{v+)T(ep;_AGHec z(aYRa_=wT&N3BkF@Cc99M?aO`rw8wsXKQ7s-)j{ppPkmiQ7#P~#=5#xi`LaUlpo<7 z#Lu*6sO9zo6{LKh86Pl92aQP|nV*rLtv;(|^q8ep>wC^VW{kRKrvqj+w;H5zC`;yZ z*_kiULSD9ehUDev(ZAlUJ%Zmir+g_xNpDCBXSC|N2IAUwUg8Sl{t$xVDx~w zGXB~b->t(t-&^zhsTZa+YpjRC9tAkeRRk}a5IEG~Br{{V2?+w()S9O!rf_llEH*(Y< z`eVU}k(9fjL8@BWfO@<}H8lMBfb##Si@#LRzvtGYjm70US5^~^uYS^cRq@py$(mN5 zw#+e&1|5oW6Gn8o?u?si3#88%bh6Ne9qj<4DX-MNUhY;SU>Ah$tOf~;VW4y3ZuWi54uy31m^=reS>JG()sBPX5 z{4;!z+cRpf)Sb1|`i2E+KX-fk?$;iq|Ps_>4QG1*G z)!r}CUNvbjM!``Erk`sqN>}~@&0L7`o0<+)pEcE0U^M0W=q&@yXtG-GnecMc+`POO zMtRa{uP}yR*B&mb&NS0iG>dmL^|?{zy4F{_*4%Jk*ZOO>nj0^z(;rXxxCOQGJT(-_ zi<9P;P);D1JA6SYYm&Oq%=l@Y-nHyON!WO|6;sRg&>+q29Rsl4Kgo0U8S}-lC*rb)}`Tf1{pK@|~1c zbcR}F+;dB-C&CezZ?TP@oZ zo%2WsIOOfW*Wdl$`sb-II)@7fWsJ_u3oh*wY8el`me#JnB%8&NSn5_`lLM>%F;H}@kwgR5;{*!Sz2b(g3_rlHDzSZ zSUz%3r?yg8QgcS9<*L_O(<1HXSU<;VgR+O@45N_qsUvgg@117M%N*nQf`fv``Db7Y zZEFpyuxK39>988cx0h;TYg&|pM*rJd`_wh9Tjl4ykj+g_Z_}1{^^E7TGk7?2+R(1U z3v3CRiyh{RkR?E$C!j;)`ny_x`Z|dH7wyTC$JbwXumWKai?+JxJku&4Q%k`fj8DJT1|-{XzNraW}Q$A*y%B=>41asP=Jt z;T1-_+JPw%Bxw>Pf0w%l*{f724QcRCmuN!AL+e2VhU??6#Lxdkez zbW7+7-XD{)ho|%Q%pc>)rt^bZ)S+c|-e6kDpF5;v=6S}XxiVcnGKZ=g9a7aCC#|TV zbOFjvqrAQ?(}$|HPTdlDf|fqKmRt6(<5Q6PBasBZ8OEkTK-%;z#jr00*w$jKksEi+Ah)FD|d@0gOFKGKt$ zlb=3l)ZoF{Bf6>mj~EN~>vmnu>1A9!qPL3s)Oh9(t#zC2{d7y9HH`s#&h3X=sp%bc zOSBc`740Ffcg)Pq&KN-pxtNLq^j5EC9Qr_`r`rDUu(7&|o?=7;S}ogWo#;s3%8M2G z%{*BzxJoNFyhp1Nx6@etr*?13+0L}c@0h252Vc0-2ali~DXn+kR_SV0=eA}RU(6)u zdx{Rvd^@I9)7Eu19$TVSs--@8gm(2s+```*p!*_fVOE;4`b({%QRWLhtJy~s82s4m zO1+y_yy;z38lKOkF14qVv3jZ2G{M(}26vZlxq~;2CU@v{!qhIt@YPx^?F#+AqgA#2 zLJ{GK9O0kLrv_v79j$_Py^E2tMyp(MNmr^luY}?HO>0&@jZQGry7Wy~-*wk5{@S#w z8QXX34()7LZnA)q(sJ4%1Jump}6)9-5CtyjAB?Uinv z*`rq|eYiUnMrBv;Z+X+6rY?4El|Rapo87HDU8Sfy?r~~Qidslf7NhAtx`Xh|xvbaL zmOd(d){3J(R}k)K6|1#O@2;*tN*lTfFV1rAHn`thDDQr~iniua!?$0roOtC?%BS}T zmDWdXl)QS=d(nY$f?_Sb)QYYywat~mov-SX$-lyVsm4CzP@LXbTiMHKeur*=kMx!m z`5pbH6n`Y*@*YF*^%Ur`HHc@``ka1Ge z?b_O2M(u-ojneAn$LP@P$SZirA7AMD#ogB_-Nfaz*w-&l2TXg9+0X&%4nOB zYhIl5=!m|QpF6Uf+W8_a55JA57v>$+t#R7RPZ-{B^#0n)0Y>B-{oxvG2G9}Pg@=BE z{_JFlJV!smHORp!n$b31zqj>{0c|{ao^Uxy)lqRe%IVFC!6b! z-V3J9b@EfqWt%ZDH9cM3eTLfSQD|?Urm;8KN;fdq2O8<$>(fj8MrDyNjBBOzO4=_2 zjlJ8n?un6Ssm0wq>Lg_hG$N;XSvRK}6HDuLOE1cx!k^LD)7rXpZs!4G`VOsYx%pHU z-Np+NsKsNT)BdhX>cX={r~ExHP-pxQBh7ehu~wz@-9dCV%%r^cjFXA_y$Q59wCQ^H zOIM3BjqM3KJuo)QxSpUtSawGiZIXBS*pALOk71{-revBIjWX)c5L#bz&83d}Qfpyf zon4TXjcvhK+26CN3wqa`PNTFo3bXk=eQ)!TN3R#&&Nc44tUp%zb}lzgRV=(xD>hK`a+B4jp{XOX&6|v&>cp@% z>FF6B58r$YRcE-3pl+N>)bA_v*ZN*Nl*jJS4h}Qdcb%gY75v1!2L53ldI$Jt=qCS+ z{=p{~a|_nLI4oJM$op?!yFGvJ>wt&XTuJV$Mrk?=nVWV=9(PsOsPU6tM%&`y{*sId zKk4z^cTjlbL-QWi$3KH7_@>178?Um!6kcU?1}pgQQGLW??l6DPy30-AEN}dIP^+4t zj(g}lzitHOf6M3Xx<=w5teuN}D-~Pr%g;#}TcH zSM4jHMcc@Yn%Clg4*tsmx;+0g>o&#v3VCDurkJPHe+=c%f<8U?n)0_zv6My~r4uV% zvF@c__)ci$i<#;(&OT$YP?oWM0bTs*yjj_}dP9$=50t)W96G8EZgOrkoi6UB+wEWd z@f4SoJaWvi{EX4**&{~e(VGpIM$?6J4Bf}hj5lvQZC6L*#&i7`8s4mUerv9h;i6Bc zRrqAgKQFp!?O5Zn<64V*H;tuZWL7-yNAy$a-Fm5MWBT?|uf5ctKO|MTq}nl#UK3q3 zGOFqoOP?Q`re1!DUYA`lyjAt;wku=NQ&mStB;{;kIqFBR*NzKqB{dN+)-Sbo01 zd-2QszM9%S^M6{nE#uPEaq2l}F8Tm3n-m?~MFDj7^UJnp1Pe=M3wiwvW$M`^V>v%2(&c zn=b|~kEbP~V2gT{t7vr3s&-Lm_OLv4lFEE$**oUXWgHQ$WK@!o(Ii1Wo! zxCj5y`Dem?`s=Minj;YB@M+<=2o<}j1-n0veuR2b`%XtdBl^tBK5Bp)x4Ya%`>x;>*1tIb zWGtjlWw68WBjdzT_(#}YUIx%{yp%iP4`DZa5%$4N>C+zEK7YEF7kHu<89`)3;1JAT zF5wCh_*K|eQ5yIfcEB~MZI1WAZ^Hb69`5ic9E831O+*LCcoL4n>)}8pY2XGNgi|JA zi7HEZ2JC?6!}KX4a{$L+kJzj3e_0yvBj62~KXMdDBmNc+!ObUQ!0-e(3fG*10acOu zCt)YNYpRrcOw;OfydoJs1SG#I4!{fHAbblB!>wPF_$WLU=8vHA0`QYHd6PJ+i)+0u zcC)E}^&&ES2sjA`;nX*zLKvP5yK6{;=im_h;53P+4``VKmJu)ii9|2%*)eyI>dKsPu9uZN>> z>lqTypW@~E6JZzpJ?w!y&Xjl`?1!VZywbpr$gtVPkIj+_PIx8khRe*Baz8u@4#6?l zQ(M}5cn$^tzXJQc$oLu=VL0h+sSt(VfmI!8@E6z)_ct(L_!HO#Ywt*T5S|TtRb6Q? zh721#ojz7(?zM2O_rxyP2YcW}upj=R$n~ZDCiJm1ZjV1t9jBCGOQh%2h89rn@wL$`d z@NclAtyE~gQp#QMVL0@Fl($$VC7;TV%5CV8UW!@*Ea9W|*-ccIl2@cIOBm5)mhFfivav$u2!|(w(%BKER z+9q_+NjjJX``~h$r923~0Y~8ru&uMycYiAJ4)}f81>c6lmf1lYTXo9q@l;XK$4+rN@>AN(`yhmY@(@-TdG zuQ&pS_lcFat9005zhuy7*3AJ;f%)4$JixEu2;A-f;=4)tJlGDGJ1FIDI0N>a_QSourTTpRceo^AJ!g=e@crM3J@6#h4sc`@IQf`N*!4CLG*aP=GDe)0_F|7JYdo54l`cGfH zFjvvkQ>Xxc3_Bi|@?)?QPCPB~emE5l!6V=Z{4vbmiQ`T3?P;$x;O;LOe;~jQ*NjMc z7=8-2KY;6qu2UB4u`~~b0d+A$U z(g1%Sk+(?}Y368@1VcWA(Ui-4dJK=X=w`tn`JZ&=X^*#i& z`B5BzUxN9Il03i&OnPOcfqq@4}2Z=!`*&D`)n^Y_!ct42sjK!-O@qtpQVC5 zLp&XJ!2PdEc_>TD+g}q$;D%Au&zABs*TqhTl=(ehF4NQXYc& zOIkbt%kL8Jg1f@L99sVzP~#5?pl@`Uz6M9(Rxv4eKQHCg?}+K+Rc3styW#-69k#t7 zmG6L{hx;PBKW)a(RrNK=43X9nw?4~bxu<6rX=75^f7dzNt zIGMiS!RDuT@B+7?FL|tp>KTgfLyTq9 zzRcy{nD){tL&kji>KJzrf?uYukg=oib=W>i8c3(FmYD;B)99;ZY#-dTnm7p0hr{p_ z)v27X{}E)=zgH@#0_mWB4Y8}p^!EYoAUs;iSHfzHxK&LlcfzY+58SYpln3AgWb^fZ z7#XAN5?~uE4SokZ;gs4^?tv%6{0(qkrAJ`A=#gxzqZZfFpm0SDoP?&tu{gd^~FSS^(Ps`Zd~ zuMHWak>P+Z!7ljOo>CzMABQ7w>qn*B_Mvp}Da;S+h*R_oonBJzhqJ|A6-35P1VrE# zz0u$zX<#GlhpW1zJP415U5h1tCmi`mobZ^$hn9=8Ond2E|FL8Q5#V1duFyv+MBoD0 zu};d57kRz7X~a)>G1e+9JLJ2jKPtq?{f}U^egu9Dy&vYMYdI8HfSF3t=A|_cWdV zc$G(x@$}QE5RwMA!amscjFbo9JU9e@1Bc;8&mw-iv^O0N!}Y!C5@6dQ0TW>dd>VGa zkGLh?53h!Uuq{K%!|;o66g~>uK9~Ny9R^7SCo&enZa6Vh%IRqj<|-cvhhSTllsk4x z`4g}k4!}ORUADxB#9n0}!}EnSU>z(0KG+SbFQwcwM9L$(#Fpp8;oahuuBH zI0!#A90P(shxs{39N%Mvl>6c3a1bsvQp&^dNSK}uBG>;z$nYJM2Akze1=}Iww~euzIl!x>AF5ka8^4cG%G_@vwq4}=5oUek2_51fz&(kDuVFuV@-d@tpdC!s-@AHc%r z0eXgwxx~9+`$=)Rm!;eV4};zCS8Trihmp~EvQ(gl;g}6hfgNzQDN^o%hr$8)T{sAT z0f*r`usSX6H=c^?zY7^3PzEoNAKn9p;e=N(fQU5E3l714*mXwAOTCJCcsLw@7r%<@ ze;66RBEWW58pwD}8gRlVU^iU;bqpBp28ZCOa0K1~t8>!+udidLaUi4l8`2;@nJtbE zyGd{W-T_Bony$fIWA+~;z6I=t)8Qbz9#-ci{)QJB4rI`j8)kzpI0JUWvtSSW1?+>% zz9sdY7o>xcum|1)2k2dOUO=y7x>SfD<2{%kMaKc<{aC`w;)$>uz6kR(*Ezob48;E^ zJ`DTeq?uA47JJn(WJD2AW0nN)Gw`^KR z&TMZL95n4!s_7hQz-5tuuCUK4b{DyXcq|-A5YL38WyL#+%BzUKBl7_0@l)min!YU# zRVP#bDhnC>^gdqV_u(+C8B)PfL(1F3Zg>LhhnK-2_-mL(VYdG#9IZviKX-WFJJJC^ z4v^gicGne$V17&>m$!Xa;@$Pcr{OUC=zCJG>Pz{juoG@GSIPtRY5BRq5y;@j53*Ol z{s!U-^Uz>JaYvXR(#7$^;Rt*Twl$LSQtzWf_(3?-h?bulSbz+E?jidm%u&Ee?;Q-ujF$N63YnrbA&KIRZ z{1OS^hp=%2K3I(wpM&l2fTa>o4{S5zx56H{&N3+v!pq?>T;?Mx=j(qI8M&N6w$r^I z411Mp2a1ov5m>%ST&4J=zF9opfYw!=4JC;aqUi4VdD;4nODos`pePt5j?!w&cn z?|KP{B4ashnYU5ukfH_B}h$Ae;~T=w6P?e}aSXQ=dzG7~Ty>VdqYCI8*9xfn7AKg4tlR zFC@T&fJLw$uJEOl2jLKGr+YabP}N;h?t(|aH2IuaUTZh%!}H_wGRl@Nn1zm)eUC;CEnt>@c@iVV{&o;OAlGH6%dWF9A;2fP?UDI0EM$ka)*C zQoqSTu?v0$_Q99n0Q`Jd;=K`M>_&!qR~l?^2m^x0!EX2j9DrMXE%E$dWnSW$u=71} z45mkpn&r8N&3La0AmgHBm``Np27E`PLDyWV5QROk`>2%r;Vm#d%hc@P{%@q*K2N+1 zcEDARaXDT8!^jwIX84r-eW`F14!}*ml?Fqw7mmPTSk0IEwZD^iC;S-fh9|Q5`tL)= zY6Jw}I>)7fF#Ig+3P=YZz#jM%?1!BvFktv4I0|nh%lH2lNQ3RamkLpM8*E!B_pw*b(DBcAJT7D$LjXVZn*+L?m2wZ=yRm1%5xO;Fe+MhN^$vEde|A1`U8HHayL95_KUsh0y6kP>O8{U zSI{6l8@8>M^6y|5T=^%7_rOoXL3kldGvt}=--4Z{>H6ROXK8?+XUqdw0SDn`SEbxR z_jX)Pvp~x}10RPyaM^289)$P6QTUZ8>aU~r`1Su*WOz7(d=vJ=jjy9Yco*zkFY$L_ zAH4mB#E0OQZ;I_3Bz`mOB-8${)OBRI5zy$CRPe#i!Xdckf23R$N`t3hH(c?yln3A= za0H(Hixi9{7(spAm9{i|5VE7#iZN~54a-^!Si9)7Ky(ByJ6Q|iRak>xWCzO*o%w<$OwKW z0SQWzoot)9Gwj(e9u529PvIc^I~;;L#7TQJp`kedAMAA^;|pZ))4F+tB{Wp{T>L2P zhNr?lcnutYe}O~rBf7K~h9`(=(v_Xk!CnM};BFSFpuUjuH()z_5O%^ftP<~o^WXsd z9vp>Fo2Ki(jcz7+iJO;@1|0AR*ae4RA6%xS#0TJ~;0U}3R&+DU?boLVoAa5{1NUR| z^*?}&DF_I`rRXW=TtU&@DmTy_4#021_OGOTN@>LJ6~~nkN8p*TeV>$NS+EOU1N&fgkHm-IC+_h|Mid!S5x|ph@CY}PO&d zFi+mW^?!x^aQg}p&ktbZ@=0D~gpm=3{f8wWxgtgkzXnI)2y8nd@y<#T?}X>TA^1Nq z-%axXyuB-HDp9Aa-U-RbfO(Q74#FLzbupTpi{KytuqM+z##t_k{bKrsMxgB1yc*LdelO^IQ!q_!oo+^x;4D*y>>_=cbJOJhy#JGGI z+z*}v^NeC#KAY_2bN@PIEJXlMF~$L#VV-J?y&vW&$Jh~=rygV9ge$@&YRUrDgR8+Q zaI>0p{pSI6Mn(q&^n?4rS#UO-508N-!*9Z~;RWy_cpbbB-c^&X|2%-5$T*IGBk<4g z53s5w@jT}lFL4E!=RRXMfO!ryc3YU|LSy%Yc}_HTx)&KdIT~k-gn5!Q_A4+?md2h7 z^Q39)Phg%qjr}>ybEvV8!9155`wAR?QS7~ojH<|}V3#Fq1UH1+zz@P*;ok6*a3=g5 z{31LWego!7*=Rss^#L+?b~Ya2T9{{PWAB1_wl?+&m}hNcUxRt_Ha0!A)ZC;NdgFp! z1?I`z*iGSjrs??afDE49jRX3^Jj)w<2+Xs+v0s9D);IQacoF;|%(K98c_F+L-V5`r zaOU;@G%|R4IIeIL=4s;CCF{r%@pN(Qd*P~Z3z%n**LA zWbpKI>{)Cp-MdA_>)|jQD)MzHKL{&&S!k@rh;SlU{dZod`$moZF>+q9sVm%pv8?FUE z2R{sZV2uV{jz;dTEDKZt_Q3Vvh!+{D$cVySVFx@A_QAtoS0(9S3T&$)eiv31#X;DP z_+79!YLkGg$O!%}ADc;}(eo1UL~FbWQsGE>ac?+Efm}Wo4&EbP4D%G0T)qbmqrGEd zI{uJBXH>I8p6ik;^rUsj18`!A2fzW?1G`|_k`iB42H=P7WyMS35aK^GO|Sn0G3oH8 znL%&G!j0&

x;=M|5f68JMSx;{oo6c~VVwd5gsJFd(6mxKEgSnBP3moqnCENb zjB@3~4){SfE%61M8MDlC8gLDXe+%ZBVYz+@o5Wv4yn{^(XvYASo2Fa06p8m9Lx$^V zG;og$Ab@~OIEbCnfb9;6KT%ZPR7`VVn+wD<$MS&q$%wp3cm`SaWY{j{UbVg`!z}?N z>0HSbR4Z|7I0z4g{qUlq@_dP}Qc>#rpA|m}^W1>kY@TVKId!f1`u|u_MzRESs>BV@ zPKY(K5{|$XDpNUa632feJ_UBckF%+#XiF&{ZJG}2_r;4~8=n_w|5FE0!7*3@5~@f8 zA?(H7+0fIDqoLrs;FVI5kgY(*gx=;rhQE85tPy0oa38dZWlFuUwrwq~jXL zeK$655|j@!%gK#oiRZ$ehT`3@;_v^Os|*=Dp(NXKuPl)pt^GDYeNw@W1|Eg|%ca~4yWv%^2Lm_?E42S7 z>~$@X1_so`h|s`UII>L2JJpi%@KW(Y*t1x?9rnYu>=MtDaPtx`Ei&4RuWgol%~`uS zV2EU>=pv~w)ihm<{t$lz+p*2}!%>vqgdNpo6IQLm9njnDa633!P09zErsI!iWRIf( z>@zczIWs%kU00TXXKrWjg+0mQR`sxit;CC9nzGo8uTo#ic_w(SzYgXZ;@J%vP&pre zJbO21yv`Z)k8pDd2*NzoJeU6f2T^WqDDi>&(V%JigT^RnZwl->BK`pmp}*3N%yE#Jv8~ zahf9mPc*?A7%rXy^E|G+2DZaIpDUZ6oXBg;H%$CYQyEZbg!oH1iUo2slX5@G=QgA5 z&r2M|9Z5W`O15LDG>`||aR>CSY3dkjdee~+ zL52_JIqNxKDQr6~J^%-Mif@Y9$K}B};xAyDW0d-%?O%(IR}SEr z*?9ojaBz(HBpmjM`?ZmH+a&Qfu;VT9KssNT?a`eTx7XzXarAj{9Xj7|xt&e@tM2V2 z!!ud}I<|)&6K^kaC9(Y>DYrc?o&X1z$N+wV9ZyO5QynDUw^GW#fE^cT{qqQWIwinQ z7ajK6BF__7dsxaH+r+OId8$}-l=A2$@hI3?TYM6>2gIE_NqppOTL0YPr^rz6NdP~& zkXKQ7s*HF%?EGB37mjWh*GZFj=V9?U*oK|>3hcu^)%FpI_YJ4@&jT2P44$=}y%~1D zDBjaWDg@{nz~xQ5ilaltFT!rxIk~)EHz{`|il2vrlf?X#JzhYc7Xv8WT{7$lcnWrB zNQH4dq}+o69i+pL8;A^&^3J`)DodQzTkIEZ@`#NI$T$+)+#WYF~D<`PVT z-EWF-!QpA*k^LmzGhKWa4n8XF<B0;HM08r&=W) zo`yr)q`W2VY+N2*B%TI`E{lJF?eoMBWlFqnuK4XD<6;!fG_U`3kA~y6EbYDALA0z? za1|M^bY{Q-lv}bXKAxVKg7*nqz&t-ZFHld@beO?@*bjf4O^08(czOo}85cOfN_Rvz zWewajSj^Lyfi@C&eX8V7&m+?<~)l2`(Q1gm;YcZG3`DcTV7xRK*zFN!=KL7XnwEbWG zM}|^|in;O&f3HA)vnl4ci}_$NC(7aY*Ba>lcT@jr;@>mK8;W^XF@Iak(PAzk7p1>C z>`=@D|7PxAjrdyz`#>?DHtqYX!T%I1PZ;*kHPob-lZyGt|Jv+dP5N&J_pjbD{of7) z#k^GF|JrHS7ps4;n9mmT&A%-Dt5SLYT!N~_TwnZGhs}$XcP>`mznF81Ilsv0Uri{= zFqdDc*NS;oF~3{P3yS%pVqR0so8Y4U)wW^*yNY>#F&{1Flf`_#n6DP|ZE=ggR_Wbh z0VO@=Ci$zpN(rSdTa4GI>d#xPbc!x%{5Dmu`*=nAXC+EiC^e$gm{Jo;O)0gYVpzf$gL>dpuC$_W9*xH z@_ngfMJbMwMyWNWHk6!{9yTt&sn?C`Vbp$0?^5Fb`??(b|8iZ{pym1d`m~e(57%jB z2gN2)qRDJkGX4I)T*vMIck7teyw6JQm7r9TQd>$7Qff!31Es&VfwwUKEqzh7!tTrT zAw7)LTY6O^@V=f{m~>13xwP?2S!)MlS(2r!QTY$OnbGMk&64)yGCk37uhmNz?!K#E zYhXAAS=t%)CYI6?_)Ql}b>ru9)*;5Krj{y3@Pegw;gu$q#+nf+Z;3D5*1$4WH};pc zRxV7s-;!i88hoa=FT9at$^X+>Hs0FAXxGA8*|7Jp#v8SEYxRx0r!8fS8_lhDquLKN z_npz)TGzPGVXbDwCt0f-*BsWeM%hxEvDJf4m@vdP&g#V+AqNfHMW#6wyd^K{wnR}vljAz zY86rowDj91TdQrDXnjA9ho5NdpG>2?I>|a$Tu5H_-=Z>wJEvN&Ta0hsqQ%YYVNEbf z54PTGJTt`7!uYHQwfXy-*8HlKl3J@SojTDZXqnj_n#Y$Xuun=dGFH*xf~%|*wUm^? z6-%rsmblh5F{`z{abvl)a$K@;X1TROTq`5#V{3&*ssC=FZSwz+XT*JCt!VUHX06z; z<-dxPlUw~e&v za{8sUN--L*vev6avql$Rvev1_xTVxcuT|FaTAP-}pjFm}mHvmJCbuy@U2d&cxO=75 zr5P=kTPw9s`B!5pZT{UsO51-gSxVa!4AH-Z-3 z2$4n+VyWmt(?zAIMyu_MYDKH9s>=5}_st|j`~SW#%suy>bM86kp1a?7=S|^v!MA@1 zF0AseaF-+|NmAVz3MHw+{kd;@`4@k|1onVlAf@6jl#Z-d(6kF0`m~>hrnIa)=N_RH zv1tEfRimmN8Z}u}K4ZO_M%QWRlMY$YN{rmQ>DAvgY@oNsd{vnvuV>v9ri);=l;*m` zpma}J*ifh$CQ;f=C@YlRl%={E%u}h=4Q0_vcejBoURmz;guJ+u@~vBohw>klq)w8Q zZ-ngp3$iq=wbwQoUUcR`#zFvJS7B<=S{jV^|WVPf1WwNE+`v)m|%9lW@FMK8_ zo}koHev_@7;wD=uF{_I-vgAUhxXG4s3_{eqP+Tib7WqU5=uM}5BjFHDo@R*2UMldH z3_{)Qdrox@{+B)h-ew^@>>Mjpq>a(+Od~sQe5$PX2{zkOx|81dLa$J(F#)_vc5^Al2+=+A{Coo$Ec%WRHh7-IMrui zr>ofbv&tpE2xVuJYx49niej+H*FRFijR$<^LY_Jlfg!5DvMfASVNI9&89x+87$=-C zM5QZxnhsNno3vIu{0Hg!e87~EeS4QE{(EKl@~M&mK@rUJqe_ik@oGA-q&Rp1le?Z! zT8F+Bu;REVTm{UkFdfQH_o2gO!-U#~Ahy1%xn%gFuhsl<%npmaU#7!~AJ_X(#|t38QQ za58zqi7BXmiT5sG(y3s^Ko~WyoVPB(d9pA02Ny?HV_bS(uB9t*L!rMjMg;%v& ztrCrO?rsvbfD+Zz2UdzSDj^1(%9a+9irwE+{`0O9(socx;y;u--Ba^y;e%>bpOR=l@aaR$a_{R=JsRdLvJZxwU3k6zopc-4-TkA zF6TJejr!`0x0Lwg?()m4m7L_^?q9!&>g%H{PYzP5l0DrIQZiB`e@kv97pznwI$V%j z?^OQmuuG15vt(<>yUcLoC<5vjDciW+iPU-Ca{B|Zy zDSSSqy(Z3TH@23v@A?aq>$fOT-3uZMUlVTHgcfPC4k?`wLtR?NgcM z7a^bDs{EbWr4xfenvzYYGWL*?A`In$)M&_~AAjbYEo=)`15>QFDN-i&XyxNsSzDi}UD$RR#kgsl4GJA&m{8{YC{Klusf}R8A zFE=YkdPd5lw4%N@Us~pEjF?ltMLTvobI3G5O@H zN>y5z+^}({8^)M#{7UL$D`1l(DTR@J zls+TI%IjAvFOL{0FMhG)=7^@U+;g?!HaaG042Bq!EvN<#QWIBG9FvPS)eWh$W?Waj zHDsN7=2>Of=<$BpD~O5a4ZlnKm4l-@$vrH}jnTc^7*~OS@dq7R{h>feLeEa=O#>bj z?12IwuuPfKPKgih?za^-x-_TBamw*A{yhT|)HcVG+VLWdK zi(vW6dt*1rOIDPO7&n8-Im=6qJ=)Jr?weQQ{zN#F-(9M-$m%AqUaE}G>MD;~s%*^q zU4HcGlC{}7Szf+ac`oM(Icb6NYtHL(%;J(4C%qxdugp{WPklswsY2N>wY!`*Px)l( zO8NXzWz4kapLC6CWP%KX<)5q`ihb;@KLRihr8qO@Q5wA^lr^5(*1 zS)QU?T9_zbnOx$vNXKOFNlKH&r8K#QWCUwE|W(*qFC*xeMA&l)rYgj-Lwxyj-kK*CJJFmKLc{nI=P3t2;1>@0!VCl<7NTK4Yz7@ugl3q1!7eoy z6R$u%0U5hgPqGKX)cSUf8h=B)b}6~gF-D)ZW}F09mHHJ?=0L71rFP_li1suk3{8zT z?^4$axlmBxqF@n;(NQkp3i5ICh0jY3u59px30~5s*iymL zx`D+Wbi21%yF4YhOBN|rhff~bA|L%qe(N9;i-dI=LG zGQs2DCJ6iucggIKXD=6+70`kmye7LM3%hu+nYWb_P>s+8R2{8}9jLY%%CRvQ6ua1_ ztNk2iiCsqq*=8>%y80*xHj}5-UW1g`WFwK)B+_0^Kz)qp=s)GVD3wDE5l%w(pnGYe zOcjE;RFIcpujllL7#8fML{@_vifk_zh_@0&UXf{w7AI|H)z7JJG3EQ6>cF9{P*Yc^ zsS{-5zts`hrP12U1tLvTAu@GnRHq(=U7~O%%C@R4+P_m>oTe^IQzz)#;I;=!M`Sg% zp^w

%!7qI4qD2`w&sO#?yg6q0y*9In!uuho)H<+ha*P}eLcA6UA%pmq|X(CLjO+z<#t>XXkr;zfdi#xjA2K@99Jn z$2lfCY07w-4958mtz)}siRx1s=b;ctT?S-itQMSqx1_$GSD^~iY42#GnRV1@m9-*U zF>!UH2o5fy1*AhCe5@IpOlDH$GoR`#Zf~iPj!v4P% zF=3k4VTq#4tEN*(sl#XLhrq*3clqvh;3SeiuB=nW95}A~ZFD{FS-@t=bJr+q-&@%H`4;GHFKGqbr8e6x%pXz+F)WJyE zyj|&iFgCCV=cSIGCzdr8YPS~3!h@+z-fm9YJk1kWZLAvu@hQ{ZnPx;kTNU6bU57{PHYmUVab|N zt-jlss8Gi>Bxp@tVLEn2XJV(pSEH_LAYsGSL234WxIASO&ppk8lp*i?dd3pD;AFaz z9TQTr`2Egqx~u{9{OHH5k5a`$zP=wIwt(iNiu-x8oe_wRGmA z96#H&>-KdbgI3-b8WR<2_lCs3$~$YFlKe?<_t6a;DE4$D2HP@DqoGuxN#V$H6zXJ% zYC2Y_lK3P){rsS)w)f|BjKLwoLa9Machn zpdWf}NsN!PvzP>I4nW2*ixFb9 z#*4%$Q~fD*)prfFA~jVhsE+eb(Kx6(3u#wm<-O`=@_C(dzB*YRRj+t`wYE(ex>CbD z?ASxrsdMHCt5j!w)Tu+~Do4M1h`A|V7t-BNq)*-F&qc5?4Q%FxSaJC@^l9VT9MO4Zc;v|%N!cGWgC%wy^?9s5xd z6NfsMFxm!}4^3vFB~!oI#BerU!mj8T9#ZPR{aB6|pnU%AG2P;%dOq-V)}CdQRDS2q zqP9@wi=h&8*~EcDat&ION@w0xzbn_TR?CNfS5AE&BcEHO)PCPZUh;<$^FwajTfaF? zs}`m?CaWrS-&aCNmHPBTrSu28d~Jc!|Hn-4({+;Lv`|?$FjhJC0I(y+rIb8W+lt8{HdXi^6dum+k>t1aosgiclpDm+o&G?txKKfX>#eS+Z1s9EFJT4c+pS?vkl z8t_%y^nZ@V1D}lR4YQHqT?sAHu1D*U*0_1D&Zsoy47m=(XBe}l6!bJnh82M@&z5oB zs=t8DCR-xO(tnP)CPm}V@x+^{wP z0uAqGR0_>6f~sk*#XMZ^P_O$BaqB&mJwJzu&d`5%4Gh$%-!oij^)VT8n_oJ#r>|-?crkYVuHm$*?XEdo_{Q@>>S|C2G z5pDV}N1|XVdk+hA>BT?)Li4hxOwst?_=OjZVtC>XuVF((eX2n9H>~RCLn1VU-ET6b za@>|B{|KHnUJXiL8ZMO1bMnO2jgR{J2k;mgd7?C)+sG>9Yz9v}$=QH|Cx`K` z4HI(moIGJS$49+Ka>5#U5;Pv!$+H1GNyM|+qe0H@Od)3#&_b8t*YOj|zXwmOgU6QA z87!(nFr=g-Zqm*}Fh+JmEvn^VR0-O6X)7fZX3^8?3s|DSSrF?uKJkGWwP)OwS-*uS z-~6f{t&$}N-5V@9I8<1oKzV~W8hbDV*%yn7Hc>QRiy9GKEu!h6XitR{wObb7Q!;P1 zG>1?D+B-zsQqmz=jSzBE1|trOXh)9%BvS!C2z4z0q0r<`8;p{{XfhfS?3v&-B#1q{ zA>IK5(qyeMGzCjjNu7PQv9wuwWKgdu(|&7iCOv8;ne(DvE2%BzrAJ`S0%X9ms2zyI z9BtEH9#7`P-e(S>?l*@v&oD zxitj#P!8B5Y4)h3)mk1+_T+_-1fT`IiH1Gp${&z`rbt}&je`6v=0r5nbSinNmc3jEv~MIfwM3&6xx7&=q@;8R zA|*i`F%qlxAC$u12bo2Vx#UHM@+pY_p&9CUZ0tDEAW^D2wf=COkex|3i9G`~@M$6? z+Ip@QrMA9UL`7TAr>Nbc@gawAoXKWV#@`IQzhmb-Q zzaoI&>j1dlfdcILUU~D67G^Wy6Ha6J#vLQ5SmU=*a5_fcTrJxi0o+a(EKbLaH5~ad z_>R$LWF_}v@87vji<&YGSOV~%x_dldYhA=&qIs|kKICbUL^&` ztadj@v{V>YOoB);`q?amf>RAEaJ}h%oNQRJh;Z*As5I--Advo`<&THRM7;qRoBnqs zTqf0mil(p;i;vp&&lt-~)VW@fnr-dwu;Se8&7yU;i0CL;kFUs#@?x~zlYCjf7jQi!?$bjIgfib|2i}%NUJa@ul^NoE)9lLt@_O-s@}900MK+D z_MW{3d*@@xhz^oR47O3XO~<~~b@)SF_bp*@xyq`4nJAU|EXs<%+84BH8YwdPiF^gM zjGE-LONdmNQHN<5x%Js5Hb}zxUY*GbNw&0bk!1mN{Gh{e5O}P5cfu8<-5cm?SQj$v z5_X!%^gSq$6>L)S?*#g(R|qNW`hB3X^-f&3ok1iA`@VuawXtX`ZbHHgNU#mL1%B0P z3MF7m4=t#WO*yyKT;-oT(NTSgt&LEWp;o5HQxP$KsMy%uR$BxpJ^zlFsuu?MxeI`e zhb=uCc86$YsRPJ5zghtV5d)U~TS{8>hXhuCQsa5Qfrn`8HQE6HS|=YEpd9&oh}`y) z;&->5{QX5G?d}5hj8bxUwzBVThBEb^M5V<)8OnLU=K%-aOH|~08A=)8T)@`#iORQt z9B_DjfO4)rvPJt#=vgR_C{dky0S^?g-|J9eJ#`SvHc4G_X=4y;74+jpEWx|AFj$TQ zsZBV=7dK|IRz54QBZnR9$;U2kT+TvTu0S)^RyDTrTx=6gWgMdUK<|yh+JoE^AT#^o z#&VX>d`2~f|BOR8n#IH~Y28E1qZ%%9Y_%VgH+{*o7z^~Cc8+?3c;5WT-R_>~a1fSJ ztz5Yg+hh<%4U;XS3Y*o;2`6|yV~KLpg?xz2QVh?;IE}I6P~=yBld+g4RbNsDoC6K} zLXrx#409InpDDwIXx9wGwG7G540}Is$nfcW{tjcwff&^!HTAw+`}lJ*i}5Lh%|cDn z&-nx$Yu}{5hQM~{lo~gmzocV_Bc8`|Br7hm+Vo55iIR9Sj-Jp%Z%^ZM+*pkK=+AtE z8;j3K{zbZfJ9yWs??zd~EjxV&L^ZGH47qEv>yLrmu^YVM+zqzI<0$n(9g)M0$6JL}m$n;!ny{3Z$@Iwn>NbUQ)c zl~6Qb*z|)nrW65!x(MKyXl+3Qd+<-(Sx|?~SgokPi50B=ZmN*_j{vj~=!qdmJAKsG zX|xYgd5{Nd=k=bJd_I*A_F%)4AJLLS8*--021^@i?Unk`K++#9YOS%wr}DENEZECa zOM0bp=EZ_qVT`Mi46B-e9lV#i3uC?(07Vq175Xo`^LS6TJMk*klqwTzO4>=Jd!hnQ zYAXaEkwbs0o5=rrHxk~->wuPguNzPEVksVvB8e;O{An-N)vKpQOY6qp^I|=`Zg&+q z|LV&B@nXs5El8@HKE*hKBbOD9$>p{0pns!SkI`cw{c$kWzKc?-qrvGMnDhmjs1*WG zJuQZz8CP*j7_$*hk^TCDqMhEEkdID3tbPlD!=X>XU()J~%?AFqH}mue1x{`HDL>@R znwc+F(V*tmU`#!xGqnzGQ;&h-RGxOW3-TNSruI>cXO6MWPZGB1KLruXug?T<%{Y5^%00A66#G$!52vs3Y zMfG(lqAWKBKv`N^vBtLPFNn0?MGbx0RIu2yaSHw73h&^{0?j+Myt^EEX(pu#(&^tN z3{LX|L7y*x-*SyjYjHNe=aD?+=1CrSLSx9fpJ5I$^!Ft5^l2JLFINt$P9KuOD}7mf z^kh2Z#nBM0QtT;{uh7At`q^2`TI6H(U2gDW(IJOBQw6Pv&|J3%DLA;eGykb6iyfq$ z2fp(YEdbL-gQlGa9>(==?L2Uz#-BsL8VHZ14Mnt3USEyguQPw#$eQs_{FpCe{E{DQ z$@X%&3F{bAhKpg1{BI%!{cm;R4>w`MygHx3g0fN_c80&+ge9}D`Ik*t>&U2UP+ySt zBd$g@=DdIua$fAnBMdA#r06~(zT-p04IRmh=G<&xe&)pjr=Jc$M@D{GTKXXYf(8j7 znz0eY$24M+Mr_+ij27-in-VC$00MA?`YUX#)W;(UBe7zmFF8zcy}<2(6&{{a)pCC$ zO9^=mx7QlW!jXc~O&!SGc3xRpGP?ucXk>$B_7VTi$nt`1$*y^pA%#3AEssw!)pnb#8|_Jiz6L;ec5|UJnAd0q&G6^O$RhvFVN#YFCT8t zKk;YHLL{IYWz&^16#G^?-Zg~9#%T+vlfva`?}66H`L@RSPCIHK&Boxd#D44qpe|1% zEF)0qb{ctMQ`#(%d8Nb9Y$6s^pw;U~i)h*aL3j3>?u4}YrM7EmU>>|CfayK|{DEw5 z+m8Pnz^wA?=lSA5c8q<)Q-jzL`N)^t8pM{$)4${%!L0q*m5B@+AKXjOo@Uzg76-za z&U+v|;eqsI*R(b7F1{IL)h8$Nb-`FbHBaPwgIT1kPvoBlv!KumZCtfExlgv?_kvlA zkdHuZblwr9P`;yW$jyl%*87M{HDX>H;n{BR>;SmB3&#DR7iq&R|Q}eX8 zAgG?$r(sfW-iDtEVd3K#aH0w-_4g7QqOpzGItR8=f3_iZx{-5hV|244+M$B_9=>4| z=K09R3L4*9qWYXY2>mKaTRKI2O)# zN3byVIzJu3^4LW_pczYH=lIfQEK5#4%FU51l>gC;MYa6e7Pa~7OD7AFLPskRd}WV)+bP-#>LHlR_iMs%0=_}(NI z5P&_wDR5w%ay%d(S;s$Y&f0mbMopo>yuLXbAP+mh2S&1X-i8BU#kf5AAeq_)mJf(z z?Y-YB)6hrj_>D+5+x!kjZ}?z{0Djv54${g^^@kIMi3T6X8X^M=&Bf6;aC#UBbu=vO z-1r2w6&Y+#dqR^||1qWf9w%v7fJ*AgLk~(r1N<2)C*Q`0b}7H`+9k0?7U@*z=mIbN+oIl@v~NBV7WE=&!lKvyB@GrGDwU+BjTQy{e2<=h^LEiJ z)BKK*kTOIQv<<-FsDBA+a8%-tr8YK|glnxmXepuz1h>&pK7%u2cL zV%8ZUA!Vi}=s198R>yw{YA|aAE&dncl;z)MnKfxqnzUskO_+5Rjp=^h!z>S&A`f;mR72b z3sYNRT)57cw_>NfH(nt{(72EfYt2$a=3rHhNeCw<9+d+~vVjg&1{_|x&MTZ^9_(}*;=^#6~$G7*p9>jIs*M*<6xAK%BL6IhI2!XB4A z{73?8&GiW|?w7Ll32Y&gr+&me64{d07wYdhw*nYz=%Uf>228_nvfx|(Mk0IE+hx%5 zOJa#^A@82Vy7f+c)6oWM`-xKFJ`4searva+lu`9>Ajka|`7d6a#NyZ{elCf%cf;k2 zdhXelZEW$^F7gmgr*OB4tLi{n1Y zzxZN1x$wQ{gv)SmgXWgIKE4r~x-ZCL_OO=do96(5kyh7H~ehoOmT-`FF{X|1EFY0bAFXcWAe^#W_`w z#*5o!DMKqDhfjnL7NXI(UAd~tk zs6MT}M0MdTg+d9lcB@BKo4^k6RZ!K=*VtgicSm7`sAOL4H9x7uXoy*sk7p#HRCv59N}7j?e7Kngv~aO;cuDkgqPMxJ_U5C12i&1@V%OETL8Yb||exjf*q96;R{ojmxiB zAi5d_59;|PmpidMx%?bu>=pOwHsraAI@8Ym{-gUoJdl6ai6zJbw(};Pu_W2f2X$ug z@=IUw`JLHjFQaw`Vn+p!NMX$fbTF*%0A1Kl-$GS<3B86RZk~oCL+;^B+7jGIS^|5aUNxSgsJ%Xap$qFHKirD<>w@iC0-xW7b#XtA zWr6w+FYdxxyT3&78T{)mELzTq;~l!QAb)ENWiF4#IX!xPsG3^DTXki<-J22bW&TuG z7R4@bTURV$Gq>{HU0H-|+0Ji{V*&hfSJtn0zb(j*`~9euT9^r0B5pW>^A&f;k?IT4 zjseC+5gqNS?pt_PH*~DChk1TC)=qA*g%<;Qlwi76CvW55cVp45ik*_RZ^zIBRQ2Yo zPKl12&f9omch)^-T1$A!;)^Lz+-xA1wu%x3q{oFS+r};3S)%)|nBY`}zuO(_-D&(v zch*cEww2d+M_Fg^s8klx`CW{4qCAzByV$6}!;+f5)q%4KT!HFoSn&oeTjx^wQX+X( zR~E(#QklPdG%484UrvQ&Uc}Q!ut5E&LbdO!eEbL&Do-jBS1e}Zz`9WV>lF+^w;lJW zD>Dk|e4zHHa9B;$i=gT(NwD53!h&*&ONO<5!FGU}QV)SQtks&8oycfeN3nXLmSwek zOdW0QKo#?vrK8DJ81f<|W=U4VLtJk7uQ^q$n}f z*^5zh4C;neE2(5Q3#B2seI$P?jYVc|K*uuSn+hZ#_C=?)bXw-b)^2iQg?Ami-!x!R z`whJ3Hi^|dPwK@&qpHz<3dA)5Y~yk@E)@+)I~;tT=k#L9a`uaSV=vZIj(w4T-iuWy zMjBT24iJW})(joo3@PU&o7#BLYGWyg4B(&kW|1tH*Y#!*BPYE8Hr$D{msdfB`i|4Q z2YsHziO-S?;f}sqPI0kCiEfZ_fMiVPPo%TRxR-7@mlyVOf$t63PCcDS&m;a~9FgxD z3APIrT;Gx+hc#a!Ui+?*--A54-wQml4+~G|y3uKI5oyaO9yrO_E@>nZt)!l3_hAuD zf7{?>Urp>iIk)#=&EsbN)@Yp|_-lHFOm~tQ(^OcMBd8x!5$)xIT7h_Nk)cteZD1x` zW76CadW5D}wXLwylIh|viVJ_mG?#aW86l%=J} z65x()l%#Iw<$Y1m?F}sH#8UV(ukFj?k_Xi_7E}-xNp>-v;==Ux&pS^W)Ic>7RUvAihbUK5g=d1LY10Ol+c<(y@BPG=^hd!C{L)x3LHO}QQ7|E=Dftpt zZb+sc@!IGn4FyZ-yv&7j7n$zhd(oEgf{W#3q>};kAd^U=2YVWW+8f$mhU!BUYz+TE_}C%@?nOgv||9V z2vMa1g`K=VPGm&3+RH9>+bu;j?pZB0nk3D_cA6$E^R+A?C?+L@s(7IaCl;0({@5TE zW>(>BQ>CR2fU3i(|F`vI5;jq#g2A?t7}V~~;W=M@=;vm>vmth z1CD%R%=lXvX{i9t?5qq*ho8Q)4xi`7SCcE>tGmXLGKG4%Md8pM(a>VwZdr7x`|kB}JtogY|f&Wy9a~W@kUx zB&@arg<%%cxNE)drhLL`;!^iwEmrIQfYGAc&(@Srb5Txlp?rZ*t}U!_HC;o8nuUM6 zY5B5T@=;vm>!lejGLX?LV1lFXuGVZOjQX`$AU3wuzim#NiA%i~2AiJ{8v|iNrDZQK3&8RNh$2je}XZd5;i6{b4a!(EKQq$-a>?sGAUOSvg7%H7F^FBapuR;6Vu@;OSJg(%D*NhZ6U2~x1B?&_4uhJ5an8S=@L{S+; zgBe6nS3O|H_g1Gfh*?!bV8%lam_gFi9YT{O*~N_H+uUym^Dw_HWWb0(h|r8MBIYn6 z6j2yKG#Ehyl|5j@6AeZXvpSKCIDrL~%kU)XAx5(y-o*yQTWG#$O+p$bhEUB#T5G+= zpBlm<%yp}Yqg0Tn+1$l0!(pVPSw|RkJ=D9_)H{?-bZ+8Oi-TcZQ&?ANxej)%ylO-2 zYNOCPM9~U}3l31t0@{f|O+t0M>KN3ZgEFZ@NXKr>h0X$@LkJJ}3Qt*#E*_w`Xbk?4 zVZ&WWUqZM{N_SQPZ}+`z#*WalcASe;Z3%lDH}OPs6ZQO-u*4#{XrQ>zumzH|ZNq7@ zQiUPnlG$Q6o;;wKf_KP}Nkp(^q0|oX~Lgpcdv!t3$s?#Ph zD|u@+)dA_$M{!}(J?zvpn~F)xK&x0}4Had1U)XD@amhz1a(@{}#KL znI%{}a7D;ikK?*>qR}yAkjA>pg_Yvk0qZ@gU@C*Sz*~zALW6TePc%co%@smdk&6I| z3zz&^KwXjU@>*UYoJ()KL?k<5(HVP?U>D+15G%zMgxcr_NUsSJkoaDT#PMB|sJ2VV z$_~Wm81`(XR9f|vkHdQHC@KIPY9{|-IO`Idjl&rAGx!)@Ds-`&;zy#1@euDl0&l;X z&L10r4Vz_^ICtV}M_^g{&o}&)5jgSc$q$cU;k~zhQ(vzgY*{U9k)JL{V_?@DXA`Ib zHNddqanx09o;!l?zise^n!|%e;#uT%K6oS>!7lTnk*ozf#7~T5146ewO9x!ItAkNi zs-?GYnCLj_F&;At55kAONNF67wE>&f(ug{XKQf9%;}moDD3;x&_i|Cj{Khg`D2`J` z?R3=xr;yrN5glIH#2J~|k-Lv(?b_kQ^2YL`7|8| zxdPW7I4BpL>mnaDmbGx7N%9u)ys<1X=JRFR1B4g}aviPAp7N(S5kL)WTgLOz6x{Y- z&@4;kw$ZpUG=;Yt$Kuk;^Mo^|xs;XSjdHReNBt9A|1PT+Uq6m@Nz6qx*6tf% zO5fDQ-D;;bG&+gK@C>gThXXDPH$2MX%$Jr5)mbj8Deh1$hP1H%)SLJfe1sQd)vF&- z9sC1LwOD{bza50m*TKWr7`oG_yvf=-b+jL3Jf(ihOATB>i2lu#Y-(X8J<#F25 zO$aC_V8$p!#>6A8rfRkbUYmtbnk~fWVoLyZGe=9{&rsA%_#Ih z|8;(DUa7Bt2x-?(C#0L>bJGkWF_hyg*~jsz#OGst{<;d4xMH&v*PA-w9fiKQcJ(?w zU*mHG*Vg9Xrdr(3_4U>G*l=!Zyis5O0zMIS$b(PooAvcy;nNdeKzI(Hj`)s(jBgl( z;mZZX@x=oAg25hqd_F|r_|^b#Kc0<`%EB0~j)gO6B}b2f2WxR{ywBioj%P#JdVXg- z>&j;HjuTjaV;eZZ`J_*!Cw(g?ux~x^MQ?G#V)o-~f}H#|Kl?a~VFkSIaTbmz13pi% zF6Q=&|NE)i4V=WNYnGrzp^o8eyb+``SpU~kw=-aOed>0?nMP*Htvz*1g*=o=8@xMF zVwm%(+qOl5uY#t#K#dI(WdT{CcO>Z>-t^RM9I?_GHzl3OKT!QQJaxOwn`W`$i4$=e zq2`O0fiDE(t2gl;f=k>BpQg1K&7IkNT^5_zCX?se^2FC993BW-*yHt(fb@X_A zeI4I1+R4MS+34O?blhQ2`G{8ecE6zw{Dn{7&;RxgFwlec?ei%@Z-G?RqZjy|Y}Thu zrY7WJO~@wz4y6wW>AZu7Pb8&ui~yxpO=$yvA!^3e$iuHYlQh6(KvxLHjZ5ZXli0)FrZ?z12-YQ%^7yzU{?a7Y zTh1BAU!KHzvDmWk$;{3=^wE5#wU<;%xISzCIhPQw&zeJc^%Q3A@SIj^E!!GOxMu73 zuWVEK>Zz=i+-n;zp32N@4o{xOLYcAbp=p?--8*ABsXoJJPiG-bCeDE{G~iU2jVXS^ zbk>o5!7Hb;WCJQg%+b``s@2xq{Ye%X+yQ(&GO7)0v4z4Mjjv_f^($;V^+|NVHGI^Q zEU8@zR;21g*mNqR9$&@7`muIbBlFkyi`~rkJjoK=FT-u<^CK$`;RM z?kqbJ9yc8EZE77-XUZ9c=jwi!u$I&?_+FjZP|U{qKTUg*udyb#1f6Db*r~|zxk|1Y)TFlWkIzl z8#;bJk#_Bq=v?zzzjkwIs9rkJX;Ti?JgS!_5cySSTpN@B;D61>NOhY(wtzjHVIp^7 zH96?c751a-E;dq2ar84~dhAdOvIntDFH9gkeX0ta5h%OOzCYFx!i zN29CJR*ZQn-n5Rn_e1riJx-A{qS1w@0}Ysl3sEW0^QV`vZU!F`CTtQ)l%n)Jp0<=3 z+bzu-tx5iNmPjE=VhnNtc-OUHHLIN@RFD(N&HiJby-J@RC_N|(s4_w zKV}JfU31f;-PmN_=2>RLb)Opd)`lik4$OikT3ch@3YSOeXFI>e&wOq6fi{1a{6OxXtVv@VGe_7)Wa~6ZszT*Y;>E$)Mf1{ zWz?kYemxramp;J1X&K*b#qGLPKl4f}8`368%hy`V_ZEPr=X&P-dW_3>uQkx~Hg!XL z%Fb+|C$WKl#smDD^7xT8EX21f?w6vG)==f(vU3cVZ5X@~c}E)?A28{W2S@zDe5;Km zg&8(e)5c}sm5AK8RQ``66!IH9Jae{nw z3pcOB-Imt;&2?;|oO!pb$$Hk$joJBdg{9)Io?T%{a^66Gi)F0g&>X0g+!WW!1=%Cf= zGw*^^d^-~zi+-m={L+FTJwYU_!POmIly22AS@TGP^Tkx|nublJ0WYR%oh+&e$&4cP znqb5`zpQvc4_+QdFCF}nJVY;d(tb;#O8s4vw##W^*X}%Q7i-qNEfz`INI}{DLbro? zx%84Q&AbEFjQv95Wg=0@&!u2q(|$ff9+k>J-@*DTQ^&R7}c2XbEw@9;Zygq4Xw5kN&EoCDfMF8|Ira9Qb*|H*PxOnD1Kuz>!IsA z`JVDKUP1>DUKNYMe%Tf_#2ho3g#P;_bgM{#pJFU6!*`ULi16X3z zsJ^kHX=62aO0C-}tRw;&h~p)6-5uO&N4yn`=$ zL_TRNOKP=rr{KIN3(V5t%;zumjXo0YO~?;Vlwwz&Svb4%E}K?~_b zimIZZ5?_g1P@!6Y;63)URKB2u6}6g*gCz&u4fNA$D@P?ZW&lTHhS;gNIdflzg^dVJ zLlEz_pQZ7P18lF{>K?y+0L^~PU0(Sfi{`Blup|8SgRE)5ln1ko`iFmTke%W0g35n< zkG0{S9%4VUB7XERdm>;L_7RQ+kmKc^>AXWZd%^4bq1rk_yseXeU(RN*5I+0}TZC(q zA0EL(mHaVpcND9ig0dfuvRGL@6Uq~xMGMb8&ZbYX22(X*)zxM_+JNh->jSK-fcPJ) zu9pY7bkqm#@7mKsTVt)W2@)OWOUlsR9m;Y~UAL?teS{HfBz(=O z`1r80KBw3cceyT|ANiOKXDfNrGps~bdzYO$!;Z^xTpC|f#V&>a;ozWB!D{x8_DknigeSn%pdEkRAUPJLk* zAA1hgyvrAyWA?N`*g)2|94x{|M3^bU;UXLlq;Vj`xk*XHq z1rc5n;bjrli11qxUKQaFB2-0qO@!A)_=^bZM0iJpcSU$lgq}%cskaDyMc71yMn3`k zMHraG<%=xc+(x95MA%M*$s+71!pBEoJWOch~I5%v;cx(NGG;m0C8E5a%fekQ^%MEIo$t3`N0 zgqK8kS%ftr{8oflMfigVRS{k@3vgY8zlg9-gujaLmI(h4;cXG#5#e1C-V>pOsj9xE zEJ8OCx{J_Lgx(_b6=4$*8b#RTD5k`tIT7)e`7$?G3B8(T| zlOmiU!dW8B72#YF&KKcA5iSlNf1{JW zlmq_INwxAPOe(u@kxkZ{i|{^3yj8<@mn>~!;m2j^I5U1OOXpeORavTI#@}V>u#WIQ z=mIXgN%wT&H{7IG-2(FU(iuJBuj>Ogx=Ww9Q~VeAfUDjT_w+@4muL8LAF0wa;CUa( z;zgJjyuuIpNTpr@ANxqZ3Cs%bnDF0yr0w1TD}ALszI!mBO5gc~pJ*aI+a%zNCep?x zI~g}$X2E5DU17Ow;706|HyZWDM(HKv3R#ji`#1m8UpnM(#e(`|K=VHXq$>dwzZTg1 z)gWnA5YAi*f_-lXOB;g2adD(1IDJQm^jmOQ@ptTbX8!77_P(e7Wl#2%=U;AkxylDk zK6E=}VD|!24g~2=1a|%;NOw0d{D&ajTfu~>3-0`Vi0+M$@VgY(_c&LgmV0n=4J22p6mTK73ygJUP=c0r~i0K`YOYho1_;9 zoMynkVG5`0CrvLiAisIY26y6TI&thJU5zPw^ar+w@d>q9K4q(TV))Tz=Fh`a){$4L zthCd@?77j4Q`4g7O`qAJeeUe(v*yohzu23wPe(t1ep;ZPN#$E>S(H1mWQ%wJKVQrG zct%g3mAhbmYBZ0z#vCH+o`r&QsH8O^sfV>n*iyo1K$0Id?v#=PsBrIXZiO^o;4VCP%lN zF)2E}May|DAi$Mr(&Q=G3uesMm>U`5C(oJ`J$p*@#068PK*emBAN|Ov!6I|U&;il$ zf%E2P&z&EgGkeyg>GP-0o)z5^rj>2G#-3oh(S3%O>94aw*_fIpB}wu4)z8PI2@;CM zi+*8A5esHbpD$(4n>T&xteKPHLzg(O`Gp1QCNIt{`|THYnLU@~$v>@QS>a9n9{BS| zI)HF|*iB~USvQ$GuR@U0R5DP7O74<} z{O_AMWibBA+|5KW;$H~CdEe7*m6yX)4h`JFqSQBq|6ouIpS-R=amV0Z86o7}k*79Dqo{$lPpvkIsaA(NVg z%CI{c^{RJk9wnh%-eEpI(cw}+PzW{vkxl&rjb5G}eoYL%<~w&<-jO~2@snhoJ}f*4 z3wf76?~uS)zvwo`xLA+S$cVNviJq}uM%JXAp{c*Sn@`JDzQ*_#&6-CgwC|8aHJscL z%W~I0o!-OEL$CMsa&tGh8NCb!KR1J~kGq$rA6l!fS#xh+vqA6a>7h61W3l6^HyC_f zvm@@))ZZ^aa`!U?>%4>AJ$?O}_(7Zm6X_X{vK z_4g0JUtnNhkjr1N_zMXM$-18%KN^gm9M%!o{Oi@L zPv49I15FPP9+Ek1_=u6CMvoag?$O7d$jY9WGiloNC;8S@axk8XO!$qB=j!h)&YbTd z<2RS_%1pg@ZKkyM3r#Ae2~R(8vu<>Bx@d(H&6TfW?66fVo(xj0H5}6l^|VQ5Q*COLUxO z>;g>hAxW12>w04Ob{!F8FG;#f41m60!{R=Y)C{nwpCly#8gXjg6R^-ENrM5?ACjc; zfK`JeDHl+}QEfh;5zl4|0rQ7RQW0R*2)ykXFdc{VUjRmrg@-8pC_Dt1Ykpjk+;D0~ z4`M!!d(fcewmB0%FzC6Al(C)1ZdoVpQr|meg)rm1uWhy zNt*zRw!npi-->S)0!rIZHGqZNQ9^>Rp@e|OohTu}QdDIP;JcFaHo-C&23QDKRm03u z@_WbtMCM`q2sjbmN29(1gHEB20dqf)q-emb4^hW}#ad`0xU_M@iG8WK?x2Q}5jBd-M#elhZ|Icc`bi80_6Q%LGqPHoHw>BLn zIDtul-%}f6QXF9JQ%vd%7(I(g{VBZwa*4hOasi7MLoQ&&)2RQ|h*UiT!GMKJ@ms!t z(lQ99^l~PB3|R9llP(e7!ldhf6@YgE^H(y-_Xj{5MtMNvS|%j{W<3X^05dm2Awdp> zfccwH5P~m4A7JiFsQ+Drc$G;90F9gBO2CS3P)PWlOmh1Xa2HBQ@C}rZ;M*u6ApPWO ze?a=--;sdHhoA^B`Y@B$0u}+j0+@aTr3TDBhJpb~AE97`{}}au36ZL^C>dY{wl8-9 z3#(8v6@orR$pCd|lfF_1R^^7w_)Eu6!{@r8Vd^DTq?hDkz)TOcXb*{1c!BOMv3zf& z0jn^28hs^JgV`k44{@xXDljqRViZj_Hw6L1W^^C~VA!kxEDQouu*9;0(We2ULy*SG zBr^<|BA_q|JtYeCXi2JxM*dhR!Y^eMwgzksg$d{pZNP(%F-c;@*yc*@kRPLFVSDhm z2Mr@1J=)kaTpcrW`jQ$`R2e7Jc7!d z3j+a@=fNWwE$aaD7r_HdAZH2WB7MMKEj^;BKUM1MY#o zV#JHV16XL@i&E@E<`Rh&VyLVu1>p!vcNE4{fVl$RIS%>>xbXzwNeHQgfJ*Rx2(RH| z{0Ih|K^&i=voPwD|5M$ahq-jV@#BATPBM1F*w@&1&5SX&s!(IAY8c(nPR1BZiwVY{ zT8X7-wHlN|DQPV&Riee%MK_d^(#2Aw_O`T9{j{{g_rA~l9&M-J>-zrw{kg7Z;`QA3 zvz(KYb26DE58YCU9-;q#OaK3tCQdIhJ5Nv_-_h-9W$~Y;4Ln2le=tgkQQC#yQ(}y^ z?01^gO=VHH$W&Z^Qv6RE%uWxNvKC9A96g>BEf#-ydKgx)SV9%)VO7auiO|_FP?=nr zT!r%Jtmv+4v3RS}`GanqbasqZBh%T@UejU;*P(}NU5n2`-}|Bh^(+=o1A2@$qz>pT z=%+KFrz!oPz9`Gyj0U4Kp`#z&K1P1rLdOZk2U2{nMX79RJCynuPNp-SGl$}%>9IfB zVu{hMYmCLB#?qw5S}gWlaxP7l&WM3Li^Vmb9{<7dR6%Dz=Ok)KXTad|6reL;crrEQ z>w}MGOSfVArq=Lu+A2ExIc8Wa!Ix<=uh5pxq4UQax((26fO6(iU-Rg89<`lMlbTO? zuag&2TRIau7E!-T>Hlw19luIKFQ-_-Z&9PS>6XrXt`&5$9uQsOXN{ zUgoWnH{)Ob3if0Gdx#EkirZCDzM(BHhCMO*e^OuI;)UWR{^=6bu%ua`{P`P;Y0lJz zF3mc(OTGMXG0m0AKbICO<)8uFRHoB~s#Jbizh<@g>eW>7m#IXkRIa7sgQ={i@;jBz z4i#6mReU#<;&oK~11baSs`yDN{p-;!m4WqDyhQ^Q*BYw$aVj4)QgMG{75|D#lO`%Y zi^`0qRGO*y?dHl7zE8zVJ5_u?6?c;I#jhkOORr>QnMGwMm7l4sqzln;DpgZx04g6) z`Hf2FRw^E#5~b2CRmG=Lsoq+}w^Mn7u1yu&(#erZSGqo(p)#SpvXr}DS=Lc`po6mP zr_%ocx~0;tqq1!6=u;M_OIen=RJ>>>niZAFomHGJV(}lTc+*t8URMPi_Ez!d+$#P|UlkvguHp^)srWf6yB}5YMUPSY$Em+3RJ_-dw0HZf z_@7iR4WPX}kotQ{#YfT8{rJEP74Pbyt)lXLCUrVU#m`XLnMGSQn070b{@FCpP!*^5 zxx~L3rYtRs%K^|6HZ zC>8foy8nM(s^SaZRPpZ1XvS35EvE?tX%_{RrRQ5JK7q;|D*m^XWylH@uenlLj;^HR zfy(o%=-8mrXtlERqY|L9Y_*DiPUYlkrClLg-%*w}RGy~dr?QU9=kF-(0^R=pj!$WI z-c?#xDkG>&rLvI9Ix1l*hp2o<P=r@WQO&05^ z#;7;+a>m`odhz`Ii}iMzv079++f9jR$NNy>h~9{D!7Io`r3%>QA6`oLT>hi z+&op?szPfF`$;WN3(}i5PHK*#p|w_JRk3%C&`GUM(J-~Ks=zzO$&*^cq7gF|UTG9N zrPVAQUCpu3GXCkmZnQe3buJxU$_l=1M&2-9Jf-#3V#|#ar?f|^FH7pD@+VQ>M|AGf zY!{aNzl<*5X`?m&8YBNZ8Z|1Tt}(vHg#Y zOgwW&8`vy-oD=;gcrW!%&uy8Jk)$>j8=jVy_egqjhWe?v)f)cR>}&Tw+q!0HHe=0M ztzXknn4^J@{@KAF#i;{#zl=Qfeo314PRvZFoZH&%XnME@;(SMsCvGYxPg14N{>a zv@djLTAng0B+<`}6_V*^eg(SwDME+BVg9+$2wl+X6^m`=eGtB@8>cU5<4PKrix8uJ z?!kxzv=-ONo!Ey%i0gBnRU9TJ$151&>YX!p+T+~ zj?3DEMWdI^hL?Yja@JvzM{2AiA7EEw5)-Ab8F0(T^uYL$wn>FAn7R4JhAXs(BioH5S2TwfJz!kFqIE733tvK!}VOPO!a52 zJmq)LHh;-cKSz1bT&YESW)al~|B*k>k*U@?@>GcG!)AWeyz>T4%%DF#si_{FV*%A&B@K7|81*1hW~g%|JzeLH*?Sk{@@W9dUxq%tou>3`wrHgIFbLpl9fyC{-SnKK7>^4kZgBfo=@9O>HWHl8J?FtCQVJL zlbrUS$`9#|4;?i3CLNq|@NTQa2k$XT&r>HT9yAZz;1`?~q{BcZq{;tjXU4s)#Z0CoRo))9LLc&hzdgYn!|t&4@eVe6{av)m5q zJVu?<&bVa${KBYqO{?bH*T6e&>@fZlSiyAC-04XfYC%KpZ`8Pv1=VBIMye$ZX@-Zm zdF&w1BT4;Ix2-vuZ4Dn(HyY8A#`Dw6KgQ9FKWvznIbs}d^$}_rF^7+Stm(b!fKJWJ z&dSX(w!E*`cFb#(-X=pWYBW+Uqdp?kH;u5Le?~v!{*0s*T9t)w>J4kDuN&s6Yn0@t zKlz#m|H?*m@E>kW6Z=ThjdkzqO&vQMb9Wy#9;x~DAZHN=4N|o&Tlqp#YgX0x-<7RX`PibV%*44j4ztdX@WB8+{XD@!NWwY zXi{+htLvN-;^QqPbMWAdwBf^ttDpYv&uD7)S4BE}v#He@+DHeVHAGEx6&$IV8&d8> z(~;^-Q(c8}s5bBn?}^X`y_dG4sZnL4-mB!4=DP9^rIHwMJCbnUhKjO!cq$F$e) zGb|tKkCr@mA2rOR*0CWLv(HMOQB5d|M;WA)ElJI2-inU(vBunu`h%rDcc#+aNe4V_ zeuVz0r&aNNO;4ZCI_X|n&r^%`TGcK zpm9SpMr7w@^O<~i(!_}wgR{rxj>(yr(W5sXtiMpdfzORyziQ32ACinC3$(`NK1-&# z9HhC>Hhz+ntY)Ve4Q^;DMYg82qVwG+M&=Ezg6~cW-RWET8k>TL=esRiWsmgcPNac8 zZAs@hI`u29HJvo+PsD@M($xBvZ3@nyq@Ouu{y*Da`Mdp#+_@PXlsR^IR>s(gBM0S- zkQpCr$s3hCl+MLtvNK20Xdk4|J~pp^(Ib4p@PE%E^SPQHn&u-tgE!u2_?uQM@g^k) zzvHyP1xiauQiqHuf7AMD$5M^!?QPwC>TGIjwYl}Zxu%%Yr*lY~wzT)8JDJJ8Hgrlj zNnKfE=cp@dOZv+-4Rj(kW$f_h_@R3@wUwIPdiaF25o%3q+9KMgv}ZY28ow_&E0Nj({@Bo&a;`rvNL%~o7>QF!y9dlo}!;BaFic1ksU^b-?jdhy@vO9?TI3P zwxta@V>N;|waVqy^j0{U*0iHm^oj{Rf<_m$rW%Le(4H&3qFt)G+@2nFADMwZyR`jA z^`%;A`}gh5lhc?U>YE2>%-hEDo7%(L!4AgW{aQWa|s6>ld?x=&`CQZccM3&P73OijxDou zhS0{n>PpGV@lH&0XSpBB8mZ>FQq^V`?WB?P;LJ{=y7ZPABh@jNZVmLNK7;G{{1c_0 zN^@t8%uLJpR+J@nnPEcdmB@>XsxtU z{fxa^wA41=_tUK*dgWQeVY85atKZOBxB8p&eU8IpZRe~J*_mT#D?g=Bh~A@1_d=Sr zovxO2Hj=Wet&BN;X*KO<9;CZs3vXBGSMxMI`l_|L@!Dm*yp^s!7Yxg7ty;>|G}`#r z%yYk!uUr{J#?XP3_DFiG40X6mTeFIRyz3+<$r4EJrVivCrXzQ)Fn^zyaTk*;*t zEa5)>*#$k#qCP%MGXgZCv23+AxY+?p48Ls-rnaRO?))-Eqr6&-=2kyGXv_`R${UkE z(JR@5-Kg1ZejXoghjFtqX>_Jp*DXCm-Rh}ZgO!cP?r1HwsXYwWds;2+#h%<>q7l1F zzk7PuYDG%-RC9Y$-(S#QSFE9f#@Rbs&pNYvruU}v2mS8TH@!y&{r=L$`$#`$hPuI- zSLE=&s`oI;tku$LshK@m<&N`?$nMdTu3I!ZPhfQ~%6x+|t;WXBb(a?GWjGJ&4sGAV z#%l-lTH2w9c^>7fw#=aMd(#n6hlUT*3!k(hyLba1GW;8~irUeK&D+wmd()P$;gS2Q z<5E{|1JypwS|YqUYf z=n&tiRWGhq^r44JTRt&eJ3{r#`WS{r8#=YGxuNA#X+!7qrCpqFKFC*^BSk;dD%YFU zH$AmrXSe>x&i;t91Mivhnr&3q^*WaQMn_$DSk@RGU9Z$_Gi_jOn)!5i3jeNw`z!e$ zU2I72`%vcprTzjpUBOMGYmMDH?V%sj4VSLhs_}I{+NYcOQ5868-WjK8pBGC~CtS(u zFT-WkS88hq7*Btr->+>LV07B9rBqkj2c)VcgW6_}FrV7w(0TCWxDjJ}s4Ww`#@uaM zB_ndyno>NybA~!Ok;c84Ki;MnvsnITOi9om*Om`3PA2G`YONfgTchpyUN}a7W3$FG z=ts01IeeR@pc}QeYn5AX8bD8)y&2|1Hc$OA;2#e%dO)Vot7!vh=D(ZA@?ZQjwvCS& zW8iV!ZJ#zUH6ue^f0~A%zb8^H-52GJYdf_kwetgwPV2N<#zVU`Z;hWQBes(>=&D0k z+;Q|9#VC48-=nAcVW2U0kJhvF(F_`956>$}y)@8xKg?&lbsi(fOr(D2-pPr*m9Io()}4_Ek{FGYT#yJ4aAAxA?+oWR%q_mA;;p ztd&D!Jv}db+uNT)A4mS3d)oUBk5_&0ZeYVl(Q>}feP1)4D!Dp4=QuD;% z($ybX<|V0w`gj=aR{E0!b^Xja{XWNvA$fzdasTl}{OS3$ZdXRqL*X-OVNGh2k@5H4o|&6LPjJ+nk;&@4QK@6H%_lh{ z)fYLGmFe~JlOMXwa))bpIKETrYO6-crfk1L_s8BG^Zuy0kCOcFnwQ}l{Fsh@%0B~F z`DgH!F`%qot|8tn|Xv%z>9_i*VRgCptXhpR}ULLE3wtlp6y{z80 z=O#)Dyv2{~Slqm%9Or9B=y(2qWGe48IydJ1eMbLmw7G--S#_Pectb8GMzEY-rNp7p zbTwH$mij!x*N3{s<#KwR8Xt{G??v~`KbrJ2k@jH5nx^YHxY z#J?NO826v5&7A%oAAfz-EB_6DMd8pvK7e|wKSsONk-SV}W1?QZUuIAB+jwe9PoxTO z=$&zWRWOhCd)Pdm|7WY;$oo�ZI=X;?sN$BX(4)q^s$9#+Sd)Q#WS?-Rj#-BZW3_ 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 diff --git a/source/adios2/toolkit/derived/parser/test-driver.cpp b/source/adios2/toolkit/derived/parser/test-driver.cpp new file mode 100644 index 0000000000..f4a1980765 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/test-driver.cpp @@ -0,0 +1,19 @@ +#include +#include +#include "ASTDriver.h" + +int +main (int argc, char *argv[]) +{ + adios2::detail::ASTDriver drv; + + std::string str_expr = "x= sim1/points/x\n y = sim1/points/y\nz=sim_1/points-more/x[ , , ::5]\na= sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; + + adios2::detail::ASTNode *result = drv.parse(str_expr); + + std::cout << "Parsed input:\n" << str_expr << std::endl; + std::cout << "Result: " << std::endl; + std::cout << result->printpretty(); + + return 0; +} diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index e556cddf5b..968edb3592 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -42,9 +42,9 @@ TEST(DerivedCorrectness, AddCorrectnessTest) auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off auto addU = bpOut.DefineDerivedVariable(derivedname, - "var x:=" + varname[0] + " \n" - "var y:=" + varname[1] + " \n" - "var z:=" + varname[2] + " \n" + "x =" + varname[0] + " \n" + "y =" + varname[1] + " \n" + "z =" + varname[2] + " \n" "x+y+z", adios2::DerivedVarType::StoreData); // clang-format on @@ -117,9 +117,9 @@ TEST(DerivedCorrectness, MagCorrectnessTest) auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off auto magU = bpOut.DefineDerivedVariable(derivedname, - "var x:=" + varname[0] + " \n" - "var y:=" + varname[1] + " \n" - "var z:=" + varname[2] + " \n" + "x =" + varname[0] + " \n" + "y =" + varname[1] + " \n" + "z =" + varname[2] + " \n" "magnitude(x,y,z)", adios2::DerivedVarType::StoreData); // clang-format on @@ -290,9 +290,9 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) auto VZ = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off auto curlV = bpOut.DefineDerivedVariable(derivedname, - "var Vx:=" + varname[0] + " \n" - "var Vy:=" + varname[1] + " \n" - "var Vz:=" + varname[2] + " \n" + "Vx =" + varname[0] + " \n" + "Vy =" + varname[1] + " \n" + "Vz =" + varname[2] + " \n" "curl(Vx,Vy,Vz)", adios2::DerivedVarType::StoreData); // clang-format on From 58fb934fda113539568bd040c2a138d3f7c915a6 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Thu, 29 Feb 2024 13:24:39 -0500 Subject: [PATCH 11/46] Removed curl changes (only left Bison parser changes) --- source/adios2/toolkit/derived/ExprHelper.h | 5 +- source/adios2/toolkit/derived/Function.cpp | 117 --------- source/adios2/toolkit/derived/Function.h | 6 - .../derived/TestBPDerivedCorrectness.cpp | 242 ------------------ 4 files changed, 1 insertion(+), 369 deletions(-) diff --git a/source/adios2/toolkit/derived/ExprHelper.h b/source/adios2/toolkit/derived/ExprHelper.h index 38672cfec4..e1d31b8bff 100644 --- a/source/adios2/toolkit/derived/ExprHelper.h +++ b/source/adios2/toolkit/derived/ExprHelper.h @@ -21,8 +21,7 @@ enum ExpressionOperator OP_ADD, OP_SQRT, OP_POW, - OP_MAGN, - OP_CURL + OP_MAGN }; struct OperatorProperty @@ -40,7 +39,6 @@ const std::map op_property = { {ExpressionOperator::OP_ADD, {"ADD", true}}, {ExpressionOperator::OP_SQRT, {"SQRT", false}}, {ExpressionOperator::OP_POW, {"POW", false}}, - {ExpressionOperator::OP_CURL, {"CURL", false}}, {ExpressionOperator::OP_MAGN, {"MAGNITUDE", false}}}; const std::map string_to_op = { @@ -51,7 +49,6 @@ const std::map string_to_op = { {"add", ExpressionOperator::OP_ADD}, {"ADD", ExpressionOperator::OP_ADD}, {"SQRT", ExpressionOperator::OP_SQRT}, {"sqrt", ExpressionOperator::OP_SQRT}, {"POW", ExpressionOperator::OP_POW}, {"^", ExpressionOperator::OP_POW}, - {"CURL", ExpressionOperator::OP_CURL}, {"curl", ExpressionOperator::OP_CURL}, {"MAGNITUDE", ExpressionOperator::OP_MAGN}, {"magnitude", ExpressionOperator::OP_MAGN}}; inline std::string get_op_name(ExpressionOperator op) { return op_property.at(op).name; } diff --git a/source/adios2/toolkit/derived/Function.cpp b/source/adios2/toolkit/derived/Function.cpp index a1c5105626..c524ac8c15 100644 --- a/source/adios2/toolkit/derived/Function.cpp +++ b/source/adios2/toolkit/derived/Function.cpp @@ -63,123 +63,6 @@ Dims SameDimsFunc(std::vector input) return input[0]; } -// Input Dims are the same, output is combination of all inputs -Dims AggrSameDimsFunc(std::vector input) -{ - // check that all dimenstions are the same - if (input.size() > 1) - { - bool dim_are_equal = std::equal(input.begin() + 1, input.end(), input.begin()); - if (!dim_are_equal) - helper::Throw("Derived", "Function", "AggrSameDimFunc", - "Invalid variable dimensions"); - } - // return original dimensions with added dimension of number of inputs - Dims output = input[0]; - output.push_back(input.size()); - return output; -} - -/* - * Linear Interpolation - average difference around point "index" - * can be used to approximate derivatives - * - * Input: - * data - assumed to be uniform/densely populated - * index - index of point of interest - * count - number of elements in data - * stride - how to access neighbours - */ -//template -float linear_interp (DerivedData input, size_t index, size_t dim) -{ - size_t stride = 1; - size_t range; - size_t offset; - float result; - float* data = (float*)input.Data; - - for (size_t i = 0; i < input.Count.size() - (dim + 1); ++i) - { - stride *= input.Count[input.Count.size() - (i + 1)]; - } - size_t ind1 = index - stride; - size_t ind2 = index + stride; - range = stride * input.Count[dim]; - offset = index % range; - - if ((offset < stride) && (range - offset <= stride)) - { - return 0; - } - else if (offset < stride) - { - result = data[ind2] - data[index]; - } - else if (range - offset <= stride) - { - result = data[index] - data[ind1]; - } - else - { - result = (data[ind2] - data[ind1]) / 2; - } - - return result; -} - -/* - * Input: 3D vector field F(x,y,z)= {F1(x,y,z), F2(x,y,z), F3(x,y,z)} - * - * inputData - (3) components of 3D vector field - * margin - how many elements to each size will be used in approximating partial derivatives - * center - include point (x,y,z) in approximating of partial derivative at that point - * - * Computation: - * curl(F(x,y,z)) = (partial(F3,y) - partial(F2,z))i - * + (partial(F1,z) - partial(F3,x))j - * + (partial(F2,x) - partial(F1,y))k - * - * boundaries are calculated only with data in block - * (ex: partial derivatives in x direction at point (0,0,0) - * only use data from (1,0,0), etc ) - * - * Return: - * (3) components of curl - */ -/* -template -std::vector computecurl3D (const std::vector inputData, size_t margin, bool center, std::function pdcomp) -*/ -DerivedData Curl3DFunc(const std::vector inputData, DataType type) -{ - // ToDo - verify how to navigate over the inputData spaces - size_t xcount = inputData[0].Count[0]; - size_t ycount = inputData[0].Count[1]; - size_t zcount = inputData[0].Count[2]; - size_t dataSize = xcount * ycount * zcount; - size_t xstride = ycount * zcount; - size_t ystride = zcount; - size_t zstride = 1; - - DerivedData curl; - // ToDo - template type - float* data = (float*)malloc(dataSize * sizeof(float) * 3); - curl.Start = inputData[0].Start; - curl.Start.push_back(0); - curl.Count = inputData[0].Count; - curl.Count.push_back(3); - - for (size_t i = 0; i < dataSize; ++i) - { - data[3 * i] = linear_interp(inputData[2], i, 1) - linear_interp(inputData[1], i, 2); - data[3 * i + 1] = linear_interp(inputData[0], i, 2) - linear_interp(inputData[2], i, 0); - data[3 * i + 2] = linear_interp(inputData[1], i, 0) - linear_interp(inputData[0], i, 1); - } - curl.Data = data; - return curl; -} - #define declare_template_instantiation(T) \ T *ApplyOneToOne(std::vector, size_t, std::function); diff --git a/source/adios2/toolkit/derived/Function.h b/source/adios2/toolkit/derived/Function.h index 4969a69186..5dfa5aba97 100644 --- a/source/adios2/toolkit/derived/Function.h +++ b/source/adios2/toolkit/derived/Function.h @@ -26,17 +26,11 @@ struct OperatorFunctions DerivedData AddFunc(std::vector input, DataType type); DerivedData MagnitudeFunc(std::vector input, DataType type); -DerivedData Curl3DFunc(std::vector input, DataType type); - -template -T linear_interp (T* data, size_t index, size_t count, size_t stride = 1); Dims SameDimsFunc(std::vector input); -Dims AggrSameDimsFunc(std::vector input); const std::map OpFunctions = { {adios2::detail::ExpressionOperator::OP_ADD, {AddFunc, SameDimsFunc}}, - {adios2::detail::ExpressionOperator::OP_CURL, {Curl3DFunc, AggrSameDimsFunc}}, {adios2::detail::ExpressionOperator::OP_MAGN, {MagnitudeFunc, SameDimsFunc}}}; template diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index 968edb3592..1ab44d2660 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -169,248 +169,6 @@ TEST(DerivedCorrectness, MagCorrectnessTest) bpFileReader.Close(); } -/* - * Linear Interpolation - average difference around point "idx" - * - */ -// T linear_interp (T* data, size_t idx, size_t count, size_t stride, size_t margin, bool center) -float linear_interp (std::vector data, size_t idx, size_t count, size_t stride) -{ - size_t ind1 = idx - stride; - size_t ind2 = idx + stride; - bool boundary = false; - if (idx < stride) - { - ind1 = idx; - boundary = true; - } - if (count - idx <= stride) - { - ind2 = idx; - boundary = true; - } - // If stride is out of bounds in both directions, ind1 = ind2 = idx - // return 0 - return (data[ind2] - data[ind1]) / (boundary? 1: 2); -} - -/* - * Input: 3D vector field F(x,y,z)= {F1(x,y,z), F2(x,y,z), F3(x,y,z)} - * - * inputData - (3) components of 3D vector field - * margin - how many elements to each size will be used in approximating partial derivatives - * center - include point (x,y,z) in approximating of partial derivative at that point - * - * Computation: - * curl(F(x,y,z)) = (partial(F3,y) - partial(F2,z))i - * + (partial(F1,z) - partial(F3,x))j - * + (partial(F2,x) - partial(F1,y))k - * - * boundaries are calculated only with data in block - * (ex: partial derivatives in x direction at point (0,0,0) - * only use data from (1,0,0), etc ) - * - * Return: - * (3) components of curl - */ -//std::vector computecurl3D -//const std::vector inputData, size_t xcount, size_t ycount, size_t zcount, size_t margin, bool center, std::function pdcomp) -std::vector> computecurl3D (std::vector inputX, std::vector inputY, std::vector inputZ, size_t xcount, size_t ycount, size_t zcount) -{ - // ToDo - verify how to navigate over the inputData spaces - size_t dataSize = xcount * ycount * zcount; - size_t xstride = ycount * zcount; - size_t ystride = zcount; - size_t zstride = 1; - - std::vector curlx(dataSize); - std::vector curly(dataSize); - std::vector curlz(dataSize); - std::vector> curl = {curlx, curly, curlz}; - // std::vector curl = {(T*)malloc(xcount * ycount * zcount * sizeof(T)), (T*)malloc(xcount * ycount * zcount * sizeof(T)), (T*)malloc(xcount * ycount * zcount * sizeof(T))}; - - for (size_t i = 0; i < xcount; ++i) - { - for (size_t j = 0; j < ycount; ++j) - { - for (size_t k = 0; k < zcount; ++k) - { - size_t idx = (i * xstride) + (j * ystride) + (k * zstride); - curl[0][idx] = linear_interp(inputZ, idx, dataSize, ystride) - linear_interp(inputY, idx, dataSize, zstride); - curl[1][idx] = linear_interp(inputX, idx, dataSize, zstride) - linear_interp(inputZ, idx, dataSize, xstride); - curl[2][idx] = linear_interp(inputY, idx, dataSize, xstride) - linear_interp(inputX, idx, dataSize, ystride); - } - } - } - - return curl; -} - -TEST(DerivedCorrectness, CurlCorrectnessTest) -{ - const size_t Nx = 25, Ny = 70, Nz = 13; - float error_limit = 0.0000001; - - // Application variable - std::vector simArray1(Nx * Ny * Nz); - std::vector simArray2(Nx * Ny * Nz); - std::vector simArray3(Nx * Ny * Nz); - for (float x = 0; x < Nx; ++x) - { - for (float y = 0; y < Ny; ++y) - { - for (float z = 0; z < Nz; ++z) - { - size_t idx = (x * Ny * Nz) + (y * Nz) + z; - // Linear curl example - simArray1[idx] = (6 * x * y) + (7 * z); - simArray2[idx] = (4 * x * z) + pow(y, 2); - simArray3[idx] = sqrt(z) + (2 * x * y); - /* Less linear example - simArray1[idx] = sin(z); - simArray2[idx] = 4 * x; - simArray3[idx] = pow(y, 2) * cos(x); - */ - /* Nonlinear example - simArray1[idx] = exp(2 * y) * sin(x); - simArray2[idx] = sqrt(z + 1) * cos(x); - simArray3[idx] = pow(x, 2) * sin(y) + (6 * z); - */ - } - } - } - - adios2::ADIOS adios; - adios2::IO bpOut = adios.DeclareIO("BPWriteExpression"); - std::vector varname = {"sim3/VX", "sim3/VY", "sim3/VZ"}; - std::string derivedname = "derived/curlV"; - - auto VX = bpOut.DefineVariable(varname[0], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - auto VY = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - auto VZ = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); - // clang-format off - auto curlV = bpOut.DefineDerivedVariable(derivedname, - "Vx =" + varname[0] + " \n" - "Vy =" + varname[1] + " \n" - "Vz =" + varname[2] + " \n" - "curl(Vx,Vy,Vz)", - adios2::DerivedVarType::StoreData); - // clang-format on - std::string filename = "expCurl.bp"; - adios2::Engine bpFileWriter = bpOut.Open(filename, adios2::Mode::Write); - - bpFileWriter.BeginStep(); - bpFileWriter.Put(VX, simArray1.data()); - bpFileWriter.Put(VY, simArray2.data()); - bpFileWriter.Put(VZ, simArray3.data()); - bpFileWriter.EndStep(); - bpFileWriter.Close(); - - adios2::IO bpIn = adios.DeclareIO("BPReadCurlExpression"); - adios2::Engine bpFileReader = bpIn.Open(filename, adios2::Mode::Read); - - std::vector readVX; - std::vector readVY; - std::vector readVZ; - // TODO/DEBUG - VERIFY DATATYPE - std::vector readCurl; - - std::vector> calcCurl; - double sum_x = 0; - double sum_y = 0; - double sum_z = 0; - // keep count of how many data points were ignored - // error values will be skipped for data values of infinity - size_t inf_x = 0; - size_t inf_y = 0; - size_t inf_z = 0; - bpFileReader.BeginStep(); - auto varVX = bpIn.InquireVariable(varname[0]); - auto varVY = bpIn.InquireVariable(varname[1]); - auto varVZ = bpIn.InquireVariable(varname[2]); - auto varCurl = bpIn.InquireVariable(derivedname); - - bpFileReader.Get(varVX, readVX); - bpFileReader.Get(varVY, readVY); - bpFileReader.Get(varVZ, readVZ); - bpFileReader.Get(varCurl, readCurl); - bpFileReader.EndStep(); - - float curl_x, curl_y, curl_z; - float err_x, err_y, err_z; - for (float x = 0; x < Nx; ++x) - { - for (float y = 0; y < Ny; ++y) - { - for (float z = 0; z < Nz; ++z) - { - size_t idx = (x * Ny * Nz) + (y * Nz) + z; - // Linear example - curl_x = -(2 * x); - curl_y = 7 - (2 * y); - curl_z = (4 * z) - (6 * x); - /* Less linear - curl_x = 2 * y * cos(x); - curl_y = cos(z) + (pow(y, 2) * sin(x)); - curl_z = 4; - */ - /* Nonlinear example - curl_x = pow(x, 2) * cos(y) - (cos(x) / (2 * sqrt(z + 1))); - curl_y = -2 * x * sin(y); - curl_z = -sqrt(z + 1) * sin(x) - (2 * exp(2 * y) * sin(x)); - */ - if (fabs(curl_x) == std::numeric_limits::infinity()) - { - err_x = 0; - ++inf_x; - } - else if (fabs(curl_x) < 1) - { - err_x = fabs(curl_x - readCurl[3 * idx]) / (1 + fabs(curl_x)); - } - else - { - err_x = fabs(curl_x - readCurl[3 * idx]) / fabs(curl_x); - } - if (fabs(curl_y) == std::numeric_limits::infinity()) - { - err_y = 0; - ++inf_y; - } - else if (fabs(curl_y) < 1) - { - err_y = fabs(curl_y - readCurl[3 * idx + 1]) / (1 + fabs(curl_y)); - } - else - { - err_y = fabs(curl_y - readCurl[3 * idx + 1]) / fabs(curl_y); - } - if (fabs(curl_z) == std::numeric_limits::infinity()) - { - err_z = 0; - ++inf_z; - } - else if (fabs(curl_z) < 1) - { - err_z = fabs(curl_z - readCurl[3 * idx + 2]) / (1 + fabs(curl_z)); - } - else - { - err_z = fabs(curl_z - readCurl[3 * idx + 2]) / fabs(curl_z); - } - sum_x += err_x; - sum_y += err_y; - sum_z += err_z; - } - } - } - bpFileReader.Close(); - EXPECT_LT((sum_x + sum_y + sum_z) / ((3 * Nx * Ny * Nz) - (inf_x + inf_y + inf_z)), error_limit); - EXPECT_LT(sum_x / ((Nx * Ny * Nz) - inf_x), error_limit); - EXPECT_LT(sum_y / ((Nx * Ny * Nz) - inf_y), error_limit); - EXPECT_LT(sum_z / ((Nx * Ny * Nz) - inf_z), error_limit); -} - int main(int argc, char **argv) { int result; From 26410433960264df2ca6386731de5f11d5d5261c Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 29 Feb 2024 15:13:13 -0500 Subject: [PATCH 12/46] run clang-format and exclude the pregen-source directory from clang-format --- scripts/ci/scripts/run-clang-format.sh | 2 +- source/adios2/toolkit/derived/Expression.cpp | 25 ++-- .../toolkit/derived/parser/ASTDriver.cpp | 70 +++++----- .../adios2/toolkit/derived/parser/ASTDriver.h | 65 +++++----- .../adios2/toolkit/derived/parser/ASTNode.cpp | 120 ++++++------------ .../adios2/toolkit/derived/parser/ASTNode.h | 55 ++++---- .../toolkit/derived/parser/test-driver.cpp | 25 ++-- .../derived/TestBPDerivedCorrectness.cpp | 2 +- 8 files changed, 162 insertions(+), 202 deletions(-) diff --git a/scripts/ci/scripts/run-clang-format.sh b/scripts/ci/scripts/run-clang-format.sh index c37ab4444d..5a29476db9 100755 --- a/scripts/ci/scripts/run-clang-format.sh +++ b/scripts/ci/scripts/run-clang-format.sh @@ -12,7 +12,7 @@ then fi # Check C and C++ code with clang-format -find source plugins testing examples bindings -regextype posix-extended -iregex '.*\.(h|c|cpp|tcc|cu)' | xargs clang-format -i +find source plugins testing examples bindings -path source/adios2/toolkit/derived/parser/pregen-source -prune -o -regextype posix-extended -iregex '.*\.(h|c|cpp|tcc|cu)' ! -path "source/adios2/toolkit/derived/parser/pregen-source/*" | xargs clang-format -i DIFF="$(git diff)" if [ -n "${DIFF}" ] then diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index aebdcfd677..7db7964dd9 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -11,23 +11,24 @@ namespace detail // helper function adios2::detail::ExpressionOperator convert_op(std::string opname) { - adios2::detail::ExpressionOperator op; - try + adios2::detail::ExpressionOperator op; + try { - op = adios2::detail::get_op(opname); + op = adios2::detail::get_op(opname); } - catch (std::out_of_range& e) + catch (std::out_of_range &e) { - helper::Throw("Derived", "ExprHelper", "get_op", "Parser cannot recognize operator '" + opname + "'."); + helper::Throw("Derived", "ExprHelper", "get_op", + "Parser cannot recognize operator '" + opname + "'."); } - return op; + return op; }; - + adios2::derived::ExpressionTree ASTNode_to_ExpressionTree(adios2::detail::ASTNode *node) { adios2::derived::ExpressionTree exprTree_node(convert_op(node->get_opname())); for (adios2::detail::ASTNode *e : node->get_subexprs()) - { + { switch (convert_op(e->get_opname())) { case adios2::detail::ExpressionOperator::OP_ALIAS: // add variable given by alias @@ -39,13 +40,13 @@ adios2::derived::ExpressionTree ASTNode_to_ExpressionTree(adios2::detail::ASTNod index_expr.add_child(e->lookup_var_path(e->alias)); expTree_node->add_child(expr); }*/ - exprTree_node.add_child(e->get_varname()); + exprTree_node.add_child(e->get_varname()); break; case adios2::detail::ExpressionOperator::OP_PATH: // add variable name - exprTree_node.add_child(e->get_varname()); + exprTree_node.add_child(e->get_varname()); break; case adios2::detail::ExpressionOperator::OP_NUM: // set the base value for the operation - exprTree_node.set_base(e->get_value()); + exprTree_node.set_base(e->get_value()); break; default: // if the children nodes are other expressions, convert them to expressions auto temp_node = ASTNode_to_ExpressionTree(e); @@ -79,7 +80,7 @@ namespace derived Expression::Expression(std::string string_exp) : ExprString(string_exp), m_Shape({0}), m_Start({0}), m_Count({0}) { - adios2::detail::ASTDriver drv; + adios2::detail::ASTDriver drv; adios2::detail::ASTNode *root_node = drv.parse(string_exp); m_Expr = adios2::detail::ASTNode_to_ExpressionTree(root_node); } diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.cpp b/source/adios2/toolkit/derived/parser/ASTDriver.cpp index 1cfaf757d5..f21cc1fef9 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.cpp +++ b/source/adios2/toolkit/derived/parser/ASTDriver.cpp @@ -7,85 +7,83 @@ namespace detail using indx_type = std::vector>; -ASTDriver::ASTDriver() -{ -} +ASTDriver::ASTDriver() {} -ASTNode* ASTDriver::getAST () +ASTNode *ASTDriver::getAST() { - // TODO: check only one ASTNode remains in holding - // else throw error that parsing failed - resolve(holding.top()); - return holding.top(); + // TODO: check only one ASTNode remains in holding + // else throw error that parsing failed + resolve(holding.top()); + return holding.top(); } -void ASTDriver::resolve(ASTNode* node) +void ASTDriver::resolve(ASTNode *node) { - if (!node->get_alias().empty()) + if (!node->get_alias().empty()) { - std::tuple var_info; - var_info = lookup_var(node->get_alias()); - node->set_varname(std::get<0>(var_info)); - node->set_indices(std::get<1>(var_info)); + std::tuple var_info; + var_info = lookup_var(node->get_alias()); + node->set_varname(std::get<0>(var_info)); + node->set_indices(std::get<1>(var_info)); } - for (ASTNode *subexpr : node->get_subexprs()) + for (ASTNode *subexpr : node->get_subexprs()) { - resolve(subexpr); + resolve(subexpr); } } std::tuple ASTDriver::lookup_var(const std::string alias) { - return aliases[alias]; + return aliases[alias]; } std::string ASTDriver::lookup_var_name(const std::string alias) { - std::tuple var = aliases[alias]; - return std::get<0>(var); + std::tuple var = aliases[alias]; + return std::get<0>(var); } indx_type ASTDriver::lookup_var_indices(const std::string alias) { - std::tuple var = aliases[alias]; - return std::get<1>(var); + std::tuple var = aliases[alias]; + return std::get<1>(var); } void ASTDriver::add_lookup_entry(std::string alias, std::string var_name, indx_type indices) { - aliases.insert({alias, {var_name, indices}}); + aliases.insert({alias, {var_name, indices}}); } void ASTDriver::add_lookup_entry(std::string alias, std::string var_name) { - aliases.insert({alias, {var_name, {}}}); + aliases.insert({alias, {var_name, {}}}); } void ASTDriver::createNode(std::string op_name, size_t numsubexprs) { - ASTNode *node = new ASTNode(op_name, numsubexprs); - for (size_t i = 1; i <= numsubexprs; ++i) + ASTNode *node = new ASTNode(op_name, numsubexprs); + for (size_t i = 1; i <= numsubexprs; ++i) { - // TODO: check that holding contains ASTNode(s) - // else throw error that parsing failed - ASTNode *subexpr = holding.top(); - node->insert_subexpr_n(subexpr, numsubexprs - i); - holding.pop(); + // TODO: check that holding contains ASTNode(s) + // else throw error that parsing failed + ASTNode *subexpr = holding.top(); + node->insert_subexpr_n(subexpr, numsubexprs - i); + holding.pop(); } - holding.push(node); + holding.push(node); } void ASTDriver::createNode(std::string alias) { - ASTNode *node = new ASTNode("ALIAS", alias); - holding.push(node); + ASTNode *node = new ASTNode("ALIAS", alias); + holding.push(node); } void ASTDriver::createNode(std::string alias, indx_type indices) { - ASTNode *node = new ASTNode("INDEX", indices); - node->pushback_subexpr(new ASTNode("ALIAS", alias)); - holding.push(node); + ASTNode *node = new ASTNode("INDEX", indices); + node->pushback_subexpr(new ASTNode("ALIAS", alias)); + holding.push(node); } } diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.h b/source/adios2/toolkit/derived/parser/ASTDriver.h index 463ded3394..2abe06dabd 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.h +++ b/source/adios2/toolkit/derived/parser/ASTDriver.h @@ -1,15 +1,14 @@ #ifndef ASTDRIVER_HH_ #define ASTDRIVER_HH_ +#include "ASTNode.h" +#include "parser.h" +#include +#include #include #include -#include -#include -#include "parser.h" -#include "ASTNode.h" -#define YY_DECL \ - adios2::detail::parser::symbol_type yylex (adios2::detail::ASTDriver& drv) +#define YY_DECL adios2::detail::parser::symbol_type yylex(adios2::detail::ASTDriver &drv) YY_DECL; namespace adios2 @@ -22,43 +21,43 @@ using indx_type = std::vector>; class ASTDriver { public: - ASTDriver (); + ASTDriver(); + + // Defined in lexer.l + ASTNode *parse(const std::string input); - // Defined in lexer.l - ASTNode *parse (const std::string input); + ASTNode *getAST(); - ASTNode* getAST (); + void resolve(ASTNode *node); - void resolve (ASTNode *node); + std::tuple lookup_var(const std::string alias); + std::string lookup_var_name(const std::string alias); + indx_type lookup_var_indices(const std::string alias); - std::tuple lookup_var(const std::string alias); - std::string lookup_var_name(const std::string alias); - indx_type lookup_var_indices(const std::string alias); + void add_lookup_entry(std::string alias, std::string var_name, indx_type indices); + void add_lookup_entry(std::string alias, std::string var_name); - void add_lookup_entry(std::string alias, std::string var_name, indx_type indices); - void add_lookup_entry(std::string alias, std::string var_name); + void createNode(std::string, size_t); + void createNode(std::string); + void createNode(std::string, indx_type); - void createNode(std::string, size_t); - void createNode(std::string); - void createNode(std::string, indx_type); - - // Whether to generate parser debug traces. - bool trace_parsing = false; - // Whether to generate scanner debug traces. - bool trace_scanning = false; - // The token's location used by the scanner. - adios2::detail::location location; + // Whether to generate parser debug traces. + bool trace_parsing = false; + // Whether to generate scanner debug traces. + bool trace_scanning = false; + // The token's location used by the scanner. + adios2::detail::location location; private: - ASTNode* root; + ASTNode *root; - // While parsing, holds ASTNodes until parent node is created - // (since root node is created last from bottom up design) - std::stack holding; + // While parsing, holds ASTNodes until parent node is created + // (since root node is created last from bottom up design) + std::stack holding; - // Variable lookup table: maps alias names - // to variable names and indices from alias definition - std::map> aliases; + // Variable lookup table: maps alias names + // to variable names and indices from alias definition + std::map> aliases; }; } diff --git a/source/adios2/toolkit/derived/parser/ASTNode.cpp b/source/adios2/toolkit/derived/parser/ASTNode.cpp index d44ae3264c..f5b74ee498 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.cpp +++ b/source/adios2/toolkit/derived/parser/ASTNode.cpp @@ -5,121 +5,83 @@ namespace adios2 namespace detail { -ASTNode::ASTNode () -{ -} +ASTNode::ASTNode() {} -ASTNode::ASTNode (std::string op) -{ - opname = op; -} +ASTNode::ASTNode(std::string op) { opname = op; } -ASTNode::ASTNode (std::string op, size_t numsubexprs) +ASTNode::ASTNode(std::string op, size_t numsubexprs) { - opname = op; - sub_exprs.resize(numsubexprs); + opname = op; + sub_exprs.resize(numsubexprs); } -ASTNode::ASTNode (std::string op, std::string a) +ASTNode::ASTNode(std::string op, std::string a) { - opname = op; - alias = a; + opname = op; + alias = a; } -ASTNode::ASTNode (std::string op, std::vector> i) +ASTNode::ASTNode(std::string op, std::vector> i) { - opname = op; - indices = i; + opname = op; + indices = i; } -void ASTNode::set_num_subexprs(size_t n) -{ - sub_exprs.resize(n); -} +void ASTNode::set_num_subexprs(size_t n) { sub_exprs.resize(n); } -void ASTNode::pushback_subexpr(ASTNode *subexpr) -{ - sub_exprs.push_back(subexpr); -} +void ASTNode::pushback_subexpr(ASTNode *subexpr) { sub_exprs.push_back(subexpr); } -void ASTNode::insert_subexpr_n(ASTNode *subexpr, size_t index) -{ - sub_exprs[index] = subexpr; -} +void ASTNode::insert_subexpr_n(ASTNode *subexpr, size_t index) { sub_exprs[index] = subexpr; } std::string ASTNode::printpretty(std::string indent) { - std::string result = indent + "Node: " + opname + "\n"; - if (!alias.empty()) + std::string result = indent + "Node: " + opname + "\n"; + if (!alias.empty()) { - result += indent + " (alias: \"" + alias + "\")\n"; + result += indent + " (alias: \"" + alias + "\")\n"; } - if (!varname.empty()) + if (!varname.empty()) { - result += indent + " (varname: \"" + varname + "\")\n"; + result += indent + " (varname: \"" + varname + "\")\n"; } - else if (!alias.empty()) + else if (!alias.empty()) { - result += indent + " (varname not found)\n"; + result += indent + " (varname not found)\n"; } - if (!indices.empty()) + if (!indices.empty()) { - result += indent + " (indices: [ "; - for (std::tuple idx: indices) - { - result += std::to_string(std::get<0>(idx)) + ":"; - result += std::to_string(std::get<1>(idx)) + ":"; - result += std::to_string(std::get<2>(idx)) + " "; - } - result += "] )\n"; + result += indent + " (indices: [ "; + for (std::tuple idx : indices) + { + result += std::to_string(std::get<0>(idx)) + ":"; + result += std::to_string(std::get<1>(idx)) + ":"; + result += std::to_string(std::get<2>(idx)) + " "; + } + result += "] )\n"; } - for (ASTNode *node: sub_exprs) + for (ASTNode *node : sub_exprs) { - result += node->printpretty(indent + " "); + result += node->printpretty(indent + " "); } - return result; + return result; } -std::vector ASTNode::get_subexprs() -{ - return sub_exprs; -} +std::vector ASTNode::get_subexprs() { return sub_exprs; } -std::string ASTNode::get_opname() -{ - return opname; -} +std::string ASTNode::get_opname() { return opname; } -std::string ASTNode::get_alias() -{ - return alias; -} +std::string ASTNode::get_alias() { return alias; } -std::string ASTNode::get_varname() -{ - return varname; -} +std::string ASTNode::get_varname() { return varname; } -std::vector> ASTNode::get_indices() -{ - return indices; -} +std::vector> ASTNode::get_indices() { return indices; } -double ASTNode::get_value() -{ - return value; -} +double ASTNode::get_value() { return value; } -void ASTNode::set_varname(const std::string s) -{ - varname = s; -} +void ASTNode::set_varname(const std::string s) { varname = s; } -void ASTNode::set_indices(const std::vector> idx) -{ - indices = idx; -} +void ASTNode::set_indices(const std::vector> idx) { indices = idx; } } } diff --git a/source/adios2/toolkit/derived/parser/ASTNode.h b/source/adios2/toolkit/derived/parser/ASTNode.h index e4495eec23..6ad8111b84 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.h +++ b/source/adios2/toolkit/derived/parser/ASTNode.h @@ -1,8 +1,8 @@ #ifndef ASTNODE_HH #define ASTNODE_HH -#include #include #include +#include namespace adios2 { @@ -12,37 +12,36 @@ namespace detail class ASTNode { public: - ASTNode (); - ASTNode (std::string); - ASTNode (std::string, size_t); - ASTNode (std::string, std::string); - ASTNode (std::string, std::vector>); - - void set_num_subexprs(size_t); - void pushback_subexpr(ASTNode*); - void insert_subexpr_n(ASTNode*, size_t); - std::string printpretty(std::string = ""); - - std::vector get_subexprs(); - std::string get_opname(); - std::string get_alias(); - std::string get_varname(); - std::vector> get_indices(); - double get_value(); - - void set_varname(const std::string); - void set_indices(const std::vector>); + ASTNode(); + ASTNode(std::string); + ASTNode(std::string, size_t); + ASTNode(std::string, std::string); + ASTNode(std::string, std::vector>); + + void set_num_subexprs(size_t); + void pushback_subexpr(ASTNode *); + void insert_subexpr_n(ASTNode *, size_t); + std::string printpretty(std::string = ""); + + std::vector get_subexprs(); + std::string get_opname(); + std::string get_alias(); + std::string get_varname(); + std::vector> get_indices(); + double get_value(); + + void set_varname(const std::string); + void set_indices(const std::vector>); private: - std::vector sub_exprs; - std::string opname; - std::string alias; - std::string varname; - std::vector> indices; - double value; + std::vector sub_exprs; + std::string opname; + std::string alias; + std::string varname; + std::vector> indices; + double value; }; } } #endif // ! ASTNODE_HH - diff --git a/source/adios2/toolkit/derived/parser/test-driver.cpp b/source/adios2/toolkit/derived/parser/test-driver.cpp index f4a1980765..c7971b5992 100644 --- a/source/adios2/toolkit/derived/parser/test-driver.cpp +++ b/source/adios2/toolkit/derived/parser/test-driver.cpp @@ -1,19 +1,20 @@ -#include -#include #include "ASTDriver.h" +#include +#include -int -main (int argc, char *argv[]) +int main(int argc, char *argv[]) { - adios2::detail::ASTDriver drv; + adios2::detail::ASTDriver drv; + + std::string str_expr = + "x= sim1/points/x\n y = sim1/points/y\nz=sim_1/points-more/x[ , , ::5]\na= " + "sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; - std::string str_expr = "x= sim1/points/x\n y = sim1/points/y\nz=sim_1/points-more/x[ , , ::5]\na= sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; + adios2::detail::ASTNode *result = drv.parse(str_expr); - adios2::detail::ASTNode *result = drv.parse(str_expr); + std::cout << "Parsed input:\n" << str_expr << std::endl; + std::cout << "Result: " << std::endl; + std::cout << result->printpretty(); - std::cout << "Parsed input:\n" << str_expr << std::endl; - std::cout << "Result: " << std::endl; - std::cout << result->printpretty(); - - return 0; + return 0; } diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index 1ab44d2660..9c310fd7c8 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -2,8 +2,8 @@ #include #include -#include #include +#include #include #include #include From 9da7307513843d17e00c23d887fd5dbdf767960b Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 29 Feb 2024 15:51:52 -0500 Subject: [PATCH 13/46] examples/derived shouldn't be included --- examples/CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 40b4c203e9..d9fb35e62a 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -4,7 +4,7 @@ #------------------------------------------------------------------------------# #add_subdirectory(basics) -add_subdirectory(derived) +#add_subdirectory(derived) #add_subdirectory(hello) #add_subdirectory(plugins) #add_subdirectory(simulations) From 3014923d5dced6034884e2180de961ea28199ac9 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 29 Feb 2024 16:15:51 -0500 Subject: [PATCH 14/46] shouldn't change examples/CMakeList --- examples/CMakeLists.txt | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index d9fb35e62a..ad7194aacf 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -3,12 +3,11 @@ # accompanying file Copyright.txt for details. #------------------------------------------------------------------------------# -#add_subdirectory(basics) -#add_subdirectory(derived) -#add_subdirectory(hello) -#add_subdirectory(plugins) -#add_subdirectory(simulations) -#add_subdirectory(useCases) -#if(ADIOS2_USE_Campaign) -# add_subdirectory(campaign) -#endif() +add_subdirectory(basics) +add_subdirectory(hello) +add_subdirectory(plugins) +add_subdirectory(simulations) +add_subdirectory(useCases) +if(ADIOS2_USE_Campaign) + add_subdirectory(campaign) +endif() From 6e9ee47daf1aa40ed62431e5d3b3fb5037a38e95 Mon Sep 17 00:00:00 2001 From: Liz Dulac <47396187+lizdulac@users.noreply.github.com> Date: Fri, 1 Mar 2024 10:34:03 -0500 Subject: [PATCH 15/46] Delete source/adios2/toolkit/derived/parser/pregen-source/Makefile Unnecessary Makefile --- .../derived/parser/pregen-source/Makefile | 17 ----------------- 1 file changed, 17 deletions(-) delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Makefile diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Makefile b/source/adios2/toolkit/derived/parser/pregen-source/Makefile deleted file mode 100644 index 73a1e490a3..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/Makefile +++ /dev/null @@ -1,17 +0,0 @@ -CC = g++ -PARSER_SOURCE = ../ -OPT = -std=c++11 -I$(PARSER_SOURCE) -I./ -BISON = bison - -simple-c: $(PARSER_SOURCE)/test-driver.cpp $(PARSER_SOURCE)/ASTDriver.cpp $(PARSER_SOURCE)/ASTNode.cpp lexer.cpp parser.cpp - $(CC) $(OPT) $^ -o $@ - -lexer.h lexer.cpp: $(PARSER_SOURCE)/lexer.l - flex --header-file=lexer.h -o lexer.cpp $(PARSER_SOURCE)/lexer.l - -parser.h parser.cpp: $(PARSER_SOURCE)/parser.y - $(BISON) --version - $(BISON) -d -v --defines=parser.h -o parser.cpp $(PARSER_SOURCE)/parser.y - -clean: - rm *.o *~ lexer.cpp lexer.h parser.cpp parser.h parser.hpp parser.output location.hh simple-c From ff27d479150dbc0b5440167c21666b0376274ed7 Mon Sep 17 00:00:00 2001 From: Liz Dulac <47396187+lizdulac@users.noreply.github.com> Date: Fri, 1 Mar 2024 10:35:36 -0500 Subject: [PATCH 16/46] Delete source/adios2/toolkit/derived/parser/CMakeLists.txt Unnecessary file --- .../toolkit/derived/parser/CMakeLists.txt | 38 ------------------- 1 file changed, 38 deletions(-) delete mode 100644 source/adios2/toolkit/derived/parser/CMakeLists.txt diff --git a/source/adios2/toolkit/derived/parser/CMakeLists.txt b/source/adios2/toolkit/derived/parser/CMakeLists.txt deleted file mode 100644 index edf04d7586..0000000000 --- a/source/adios2/toolkit/derived/parser/CMakeLists.txt +++ /dev/null @@ -1,38 +0,0 @@ -project(simple-test) -cmake_minimum_required(VERSION 3.18) -enable_language(CXX) -set(CMAKE_CXX_STANDARD 11) - -set(PARSER_SOURCE "./" CACHE PATH "Expression Parser source code") - -# Hardcoded for debugging - DELETE -set(BISON_EXECUTABLE "/usr/local/Cellar/bison/3.8.2/bin/bison" CACHE PATH "Bison executable") -set(FLEX_EXECUTABLE "/usr/local/Cellar/flex/2.6.4_2/bin/flex" CACHE PATH "Flex executable") - -find_package(BISON) -find_package(FLEX) - -# if(NOT ADIOS2_EXPRESSIONS_REGEN OR NOT BISON_FOUND OR NOT FLEX_FOUND) -# -# else() - BISON_TARGET(MyParser - parser.y - ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp - DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/parser.h) - FLEX_TARGET(MyScanner - lexer.l - ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp - DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/lexer.h) - ADD_FLEX_BISON_DEPENDENCY(MyScanner MyParser) -# endif() - -include_directories(${CMAKE_CURRENT_BINARY_DIR} ${PARSER_SOURCE}) -add_executable(simple-test - ${PARSER_SOURCE}/driver.cpp - ${PARSER_SOURCE}/ASTNode.cpp - ${PARSER_SOURCE}/ASTNode.h - ${BISON_MyParser_OUTPUTS} - ${FLEX_MyScanner_OUTPUTS} -) - -target_include_directories(simple-test PRIVATE ${CMAKE_CURRENT_BINARY_DIR} ${PARSER_SOURCE}) From 0dd4320665345824860a0c1db653d2606143ffe1 Mon Sep 17 00:00:00 2001 From: Liz Dulac <47396187+lizdulac@users.noreply.github.com> Date: Fri, 1 Mar 2024 10:48:34 -0500 Subject: [PATCH 17/46] Delete source/adios2/toolkit/derived/parser/pregen-source/parser.output Unnecessary output file --- .../parser/pregen-source/parser.output | 577 ------------------ 1 file changed, 577 deletions(-) delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/parser.output diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.output b/source/adios2/toolkit/derived/parser/pregen-source/parser.output deleted file mode 100644 index d7c0f695f3..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.output +++ /dev/null @@ -1,577 +0,0 @@ -State 11 conflicts: 2 reduce/reduce -State 26 conflicts: 2 reduce/reduce -State 27 conflicts: 2 reduce/reduce - - -Grammar - - 0 $accept: lines $end - - 1 lines: assignment "\n" lines - 2 | exp - - 3 assignment: "identifier" "=" VARNAME - 4 | "identifier" "=" "identifier" - 5 | "identifier" "=" VARNAME "[" indices_list "]" - 6 | "identifier" "=" "identifier" "[" indices_list "]" - - 7 exp: "number" - 8 | exp OPERATOR exp - 9 | "(" exp ")" - 10 | "identifier" "(" list ")" - 11 | "identifier" "[" indices_list "]" - 12 | "identifier" - - 13 indices_list: ε - 14 | indices_list "," index - 15 | index - - 16 index: ε - 17 | "number" ":" "number" ":" "number" - 18 | ":" "number" ":" "number" - 19 | "number" ":" ":" "number" - 20 | "number" ":" "number" ":" - 21 | "number" ":" "number" - 22 | ":" ":" "number" - 23 | ":" "number" ":" - 24 | ":" "number" - 25 | "number" ":" ":" - 26 | "number" ":" - 27 | "number" - - 28 list: ε - 29 | exp "," list - 30 | exp - - -Terminals, with rules where they appear - - $end (0) 0 - error (256) - "=" (258) 3 4 5 6 - "," (259) 14 29 - ":" (260) 17 18 19 20 21 22 23 24 25 26 - "(" (261) 9 10 - ")" (262) 9 10 - "[" (263) 5 6 11 - "]" (264) 5 6 11 - "\n" (265) 1 - OPERATOR (266) 8 - "identifier" (267) 3 4 5 6 10 11 12 - VARNAME (268) 3 5 - "number" (269) 7 17 18 19 20 21 22 23 24 25 26 27 - - -Nonterminals, with rules where they appear - - $accept (15) - on left: 0 - lines (16) - on left: 1 2 - on right: 0 1 - assignment (17) - on left: 3 4 5 6 - on right: 1 - exp (18) - on left: 7 8 9 10 11 12 - on right: 2 8 9 29 30 - indices_list >> (19) - on left: 13 14 15 - on right: 5 6 11 14 - index > (20) - on left: 16 17 18 19 20 21 22 23 24 25 26 27 - on right: 14 15 - list (21) - on left: 28 29 30 - on right: 10 29 - - -State 0 - - 0 $accept: • lines $end - - "(" shift, and go to state 1 - "identifier" shift, and go to state 2 - "number" shift, and go to state 3 - - lines go to state 4 - assignment go to state 5 - exp go to state 6 - - -State 1 - - 9 exp: "(" • exp ")" - - "(" shift, and go to state 1 - "identifier" shift, and go to state 7 - "number" shift, and go to state 3 - - exp go to state 8 - - -State 2 - - 3 assignment: "identifier" • "=" VARNAME - 4 | "identifier" • "=" "identifier" - 5 | "identifier" • "=" VARNAME "[" indices_list "]" - 6 | "identifier" • "=" "identifier" "[" indices_list "]" - 10 exp: "identifier" • "(" list ")" - 11 | "identifier" • "[" indices_list "]" - 12 | "identifier" • - - "=" shift, and go to state 9 - "(" shift, and go to state 10 - "[" shift, and go to state 11 - - $default reduce using rule 12 (exp) - - -State 3 - - 7 exp: "number" • - - $default reduce using rule 7 (exp) - - -State 4 - - 0 $accept: lines • $end - - $end shift, and go to state 12 - - -State 5 - - 1 lines: assignment • "\n" lines - - "\n" shift, and go to state 13 - - -State 6 - - 2 lines: exp • - 8 exp: exp • OPERATOR exp - - OPERATOR shift, and go to state 14 - - $default reduce using rule 2 (lines) - - -State 7 - - 10 exp: "identifier" • "(" list ")" - 11 | "identifier" • "[" indices_list "]" - 12 | "identifier" • - - "(" shift, and go to state 10 - "[" shift, and go to state 11 - - $default reduce using rule 12 (exp) - - -State 8 - - 8 exp: exp • OPERATOR exp - 9 | "(" exp • ")" - - ")" shift, and go to state 15 - OPERATOR shift, and go to state 14 - - -State 9 - - 3 assignment: "identifier" "=" • VARNAME - 4 | "identifier" "=" • "identifier" - 5 | "identifier" "=" • VARNAME "[" indices_list "]" - 6 | "identifier" "=" • "identifier" "[" indices_list "]" - - "identifier" shift, and go to state 16 - VARNAME shift, and go to state 17 - - -State 10 - - 10 exp: "identifier" "(" • list ")" - - "(" shift, and go to state 1 - "identifier" shift, and go to state 7 - "number" shift, and go to state 3 - - $default reduce using rule 28 (list) - - exp go to state 18 - list go to state 19 - - -State 11 - - 11 exp: "identifier" "[" • indices_list "]" - - ":" shift, and go to state 20 - "number" shift, and go to state 21 - - "," reduce using rule 13 (indices_list) - "," [reduce using rule 16 (index)] - "]" reduce using rule 13 (indices_list) - "]" [reduce using rule 16 (index)] - $default reduce using rule 13 (indices_list) - - indices_list go to state 22 - index go to state 23 - - -State 12 - - 0 $accept: lines $end • - - $default accept - - -State 13 - - 1 lines: assignment "\n" • lines - - "(" shift, and go to state 1 - "identifier" shift, and go to state 2 - "number" shift, and go to state 3 - - lines go to state 24 - assignment go to state 5 - exp go to state 6 - - -State 14 - - 8 exp: exp OPERATOR • exp - - "(" shift, and go to state 1 - "identifier" shift, and go to state 7 - "number" shift, and go to state 3 - - exp go to state 25 - - -State 15 - - 9 exp: "(" exp ")" • - - $default reduce using rule 9 (exp) - - -State 16 - - 4 assignment: "identifier" "=" "identifier" • - 6 | "identifier" "=" "identifier" • "[" indices_list "]" - - "[" shift, and go to state 26 - - $default reduce using rule 4 (assignment) - - -State 17 - - 3 assignment: "identifier" "=" VARNAME • - 5 | "identifier" "=" VARNAME • "[" indices_list "]" - - "[" shift, and go to state 27 - - $default reduce using rule 3 (assignment) - - -State 18 - - 8 exp: exp • OPERATOR exp - 29 list: exp • "," list - 30 | exp • - - "," shift, and go to state 28 - OPERATOR shift, and go to state 14 - - $default reduce using rule 30 (list) - - -State 19 - - 10 exp: "identifier" "(" list • ")" - - ")" shift, and go to state 29 - - -State 20 - - 18 index: ":" • "number" ":" "number" - 22 | ":" • ":" "number" - 23 | ":" • "number" ":" - 24 | ":" • "number" - - ":" shift, and go to state 30 - "number" shift, and go to state 31 - - -State 21 - - 17 index: "number" • ":" "number" ":" "number" - 19 | "number" • ":" ":" "number" - 20 | "number" • ":" "number" ":" - 21 | "number" • ":" "number" - 25 | "number" • ":" ":" - 26 | "number" • ":" - 27 | "number" • - - ":" shift, and go to state 32 - - $default reduce using rule 27 (index) - - -State 22 - - 11 exp: "identifier" "[" indices_list • "]" - 14 indices_list: indices_list • "," index - - "," shift, and go to state 33 - "]" shift, and go to state 34 - - -State 23 - - 15 indices_list: index • - - $default reduce using rule 15 (indices_list) - - -State 24 - - 1 lines: assignment "\n" lines • - - $default reduce using rule 1 (lines) - - -State 25 - - 8 exp: exp • OPERATOR exp - 8 | exp OPERATOR exp • - - $default reduce using rule 8 (exp) - - -State 26 - - 6 assignment: "identifier" "=" "identifier" "[" • indices_list "]" - - ":" shift, and go to state 20 - "number" shift, and go to state 21 - - "," reduce using rule 13 (indices_list) - "," [reduce using rule 16 (index)] - "]" reduce using rule 13 (indices_list) - "]" [reduce using rule 16 (index)] - $default reduce using rule 13 (indices_list) - - indices_list go to state 35 - index go to state 23 - - -State 27 - - 5 assignment: "identifier" "=" VARNAME "[" • indices_list "]" - - ":" shift, and go to state 20 - "number" shift, and go to state 21 - - "," reduce using rule 13 (indices_list) - "," [reduce using rule 16 (index)] - "]" reduce using rule 13 (indices_list) - "]" [reduce using rule 16 (index)] - $default reduce using rule 13 (indices_list) - - indices_list go to state 36 - index go to state 23 - - -State 28 - - 29 list: exp "," • list - - "(" shift, and go to state 1 - "identifier" shift, and go to state 7 - "number" shift, and go to state 3 - - $default reduce using rule 28 (list) - - exp go to state 18 - list go to state 37 - - -State 29 - - 10 exp: "identifier" "(" list ")" • - - $default reduce using rule 10 (exp) - - -State 30 - - 22 index: ":" ":" • "number" - - "number" shift, and go to state 38 - - -State 31 - - 18 index: ":" "number" • ":" "number" - 23 | ":" "number" • ":" - 24 | ":" "number" • - - ":" shift, and go to state 39 - - $default reduce using rule 24 (index) - - -State 32 - - 17 index: "number" ":" • "number" ":" "number" - 19 | "number" ":" • ":" "number" - 20 | "number" ":" • "number" ":" - 21 | "number" ":" • "number" - 25 | "number" ":" • ":" - 26 | "number" ":" • - - ":" shift, and go to state 40 - "number" shift, and go to state 41 - - $default reduce using rule 26 (index) - - -State 33 - - 14 indices_list: indices_list "," • index - - ":" shift, and go to state 20 - "number" shift, and go to state 21 - - $default reduce using rule 16 (index) - - index go to state 42 - - -State 34 - - 11 exp: "identifier" "[" indices_list "]" • - - $default reduce using rule 11 (exp) - - -State 35 - - 6 assignment: "identifier" "=" "identifier" "[" indices_list • "]" - 14 indices_list: indices_list • "," index - - "," shift, and go to state 33 - "]" shift, and go to state 43 - - -State 36 - - 5 assignment: "identifier" "=" VARNAME "[" indices_list • "]" - 14 indices_list: indices_list • "," index - - "," shift, and go to state 33 - "]" shift, and go to state 44 - - -State 37 - - 29 list: exp "," list • - - $default reduce using rule 29 (list) - - -State 38 - - 22 index: ":" ":" "number" • - - $default reduce using rule 22 (index) - - -State 39 - - 18 index: ":" "number" ":" • "number" - 23 | ":" "number" ":" • - - "number" shift, and go to state 45 - - $default reduce using rule 23 (index) - - -State 40 - - 19 index: "number" ":" ":" • "number" - 25 | "number" ":" ":" • - - "number" shift, and go to state 46 - - $default reduce using rule 25 (index) - - -State 41 - - 17 index: "number" ":" "number" • ":" "number" - 20 | "number" ":" "number" • ":" - 21 | "number" ":" "number" • - - ":" shift, and go to state 47 - - $default reduce using rule 21 (index) - - -State 42 - - 14 indices_list: indices_list "," index • - - $default reduce using rule 14 (indices_list) - - -State 43 - - 6 assignment: "identifier" "=" "identifier" "[" indices_list "]" • - - $default reduce using rule 6 (assignment) - - -State 44 - - 5 assignment: "identifier" "=" VARNAME "[" indices_list "]" • - - $default reduce using rule 5 (assignment) - - -State 45 - - 18 index: ":" "number" ":" "number" • - - $default reduce using rule 18 (index) - - -State 46 - - 19 index: "number" ":" ":" "number" • - - $default reduce using rule 19 (index) - - -State 47 - - 17 index: "number" ":" "number" ":" • "number" - 20 | "number" ":" "number" ":" • - - "number" shift, and go to state 48 - - $default reduce using rule 20 (index) - - -State 48 - - 17 index: "number" ":" "number" ":" "number" • - - $default reduce using rule 17 (index) From 667716c7cd1f067b904ccf00ce07ee3f1a70bf65 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Fri, 1 Mar 2024 11:20:13 -0500 Subject: [PATCH 18/46] Kill redundancy in run-clang-format find command --- scripts/ci/scripts/run-clang-format.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/scripts/ci/scripts/run-clang-format.sh b/scripts/ci/scripts/run-clang-format.sh index 5a29476db9..b85f7fa636 100755 --- a/scripts/ci/scripts/run-clang-format.sh +++ b/scripts/ci/scripts/run-clang-format.sh @@ -12,7 +12,7 @@ then fi # Check C and C++ code with clang-format -find source plugins testing examples bindings -path source/adios2/toolkit/derived/parser/pregen-source -prune -o -regextype posix-extended -iregex '.*\.(h|c|cpp|tcc|cu)' ! -path "source/adios2/toolkit/derived/parser/pregen-source/*" | xargs clang-format -i +find source plugins testing examples bindings -regextype posix-extended -iregex '.*\.(h|c|cpp|tcc|cu)' ! -path "source/adios2/toolkit/derived/parser/pregen-source/*" | xargs clang-format -i DIFF="$(git diff)" if [ -n "${DIFF}" ] then From c4855b60a1c4bdd0a982bead14432d6732a50bf5 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Fri, 1 Mar 2024 12:49:19 -0500 Subject: [PATCH 19/46] remove binary --- CMakeLists.txt | 2 +- .../derived/parser/pregen-source/simple-c | Bin 373136 -> 0 bytes 2 files changed, 1 insertion(+), 1 deletion(-) delete mode 100755 source/adios2/toolkit/derived/parser/pregen-source/simple-c diff --git a/CMakeLists.txt b/CMakeLists.txt index 8511e152bf..8ee0331e55 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -185,7 +185,7 @@ adios_option(Sodium "Enable support for Sodium for encryption" AUTO) adios_option(Catalyst "Enable support for in situ visualization plugin using ParaView Catalyst" AUTO) adios_option(Campaign "Enable support for Campaigns (requires SQLite3 and ZLIB)" OFF) adios_option(AWSSDK "Enable support for S3 compatible storage using AWS SDK's S3 module" OFF) -adios_option(Derived_Variable "Enable support for derived variables" OFF) +adios_option(Derived_Variable "Enable support for derived variables" ON) adios_option(PIP "Enable support for pip packaging" OFF) option(ADIOS2_Blosc2_PREFER_SHARED "Prefer shared Blosc2 libraries" ON) diff --git a/source/adios2/toolkit/derived/parser/pregen-source/simple-c b/source/adios2/toolkit/derived/parser/pregen-source/simple-c deleted file mode 100755 index 44f43e47aa64e3c741334b0696db2933052329ab..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 373136 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 No$Gq`?Kl4O{{VI;(|!N| From 228b1ad0759c37ca2d660df679a364566fceb3df Mon Sep 17 00:00:00 2001 From: lizdulac Date: Fri, 1 Mar 2024 14:29:32 -0500 Subject: [PATCH 20/46] Fixing CI warnings - unused objects, class members initialized out of order --- source/adios2/core/VariableDerived.cpp | 2 +- source/adios2/toolkit/derived/Expression.cpp | 2 +- .../toolkit/derived/parser/test-driver.cpp | 20 ------------ .../derived/TestBPDerivedCorrectness.cpp | 32 +++++++++---------- 4 files changed, 18 insertions(+), 38 deletions(-) delete mode 100644 source/adios2/toolkit/derived/parser/test-driver.cpp diff --git a/source/adios2/core/VariableDerived.cpp b/source/adios2/core/VariableDerived.cpp index 670ad0bc35..d06c5601d6 100644 --- a/source/adios2/core/VariableDerived.cpp +++ b/source/adios2/core/VariableDerived.cpp @@ -11,7 +11,7 @@ VariableDerived::VariableDerived(const std::string &name, adios2::derived::Expre const DerivedVarType varType) : VariableBase(name, exprType, helper::GetDataTypeSize(exprType), expr.GetShape(), expr.GetStart(), expr.GetCount(), isConstant), - m_Expr(expr), m_DerivedType(varType) + m_DerivedType(varType), m_Expr(expr) { } diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index 7db7964dd9..b33757cdc0 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -78,7 +78,7 @@ namespace derived { Expression::Expression(std::string string_exp) -: ExprString(string_exp), m_Shape({0}), m_Start({0}), m_Count({0}) +: m_Shape({0}), m_Start({0}), m_Count({0}), ExprString(string_exp) { adios2::detail::ASTDriver drv; adios2::detail::ASTNode *root_node = drv.parse(string_exp); diff --git a/source/adios2/toolkit/derived/parser/test-driver.cpp b/source/adios2/toolkit/derived/parser/test-driver.cpp deleted file mode 100644 index c7971b5992..0000000000 --- a/source/adios2/toolkit/derived/parser/test-driver.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "ASTDriver.h" -#include -#include - -int main(int argc, char *argv[]) -{ - adios2::detail::ASTDriver drv; - - std::string str_expr = - "x= sim1/points/x\n y = sim1/points/y\nz=sim_1/points-more/x[ , , ::5]\na= " - "sim_1/points-more/.extra\\a[0::2, :2:,::5,32]\na+(x*y)^curl(z[1, 2:3:],sqrt(a))"; - - adios2::detail::ASTNode *result = drv.parse(str_expr); - - std::cout << "Parsed input:\n" << str_expr << std::endl; - std::cout << "Result: " << std::endl; - std::cout << result->printpretty(); - - return 0; -} diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index 9c310fd7c8..d14b931639 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -41,17 +41,17 @@ TEST(DerivedCorrectness, AddCorrectnessTest) auto Uy = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off - auto addU = bpOut.DefineDerivedVariable(derivedname, - "x =" + varname[0] + " \n" - "y =" + varname[1] + " \n" - "z =" + varname[2] + " \n" - "x+y+z", - adios2::DerivedVarType::StoreData); + bpOut.DefineDerivedVariable(derivedname, + "x =" + varname[0] + " \n" + "y =" + varname[1] + " \n" + "z =" + varname[2] + " \n" + "x+y+z", + adios2::DerivedVarType::StoreData); // clang-format on std::string filename = "expAdd.bp"; adios2::Engine bpFileWriter = bpOut.Open(filename, adios2::Mode::Write); - for (int i = 0; i < steps; i++) + for (size_t i = 0; i < steps; i++) { bpFileWriter.BeginStep(); bpFileWriter.Put(Ux, simArray1.data()); @@ -71,7 +71,7 @@ TEST(DerivedCorrectness, AddCorrectnessTest) float calcA; float epsilon = 0.01; - for (int i = 0; i < steps; i++) + for (size_t i = 0; i < steps; i++) { bpFileReader.BeginStep(); bpFileReader.Get(varname[0], readUx); @@ -116,17 +116,17 @@ TEST(DerivedCorrectness, MagCorrectnessTest) auto Uy = bpOut.DefineVariable(varname[1], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off - auto magU = bpOut.DefineDerivedVariable(derivedname, - "x =" + varname[0] + " \n" - "y =" + varname[1] + " \n" - "z =" + varname[2] + " \n" - "magnitude(x,y,z)", - adios2::DerivedVarType::StoreData); + bpOut.DefineDerivedVariable(derivedname, + "x =" + varname[0] + " \n" + "y =" + varname[1] + " \n" + "z =" + varname[2] + " \n" + "magnitude(x,y,z)", + adios2::DerivedVarType::StoreData); // clang-format on std::string filename = "expMagnitude.bp"; adios2::Engine bpFileWriter = bpOut.Open(filename, adios2::Mode::Write); - for (int i = 0; i < steps; i++) + for (size_t i = 0; i < steps; i++) { bpFileWriter.BeginStep(); bpFileWriter.Put(Ux, simArray1.data()); @@ -146,7 +146,7 @@ TEST(DerivedCorrectness, MagCorrectnessTest) float calcM; float epsilon = 0.01; - for (int i = 0; i < steps; i++) + for (size_t i = 0; i < steps; i++) { bpFileReader.BeginStep(); auto varx = bpIn.InquireVariable(varname[0]); From ed49423d09bb58ba03736cb7f4da80f2ee3524bb Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sat, 2 Mar 2024 15:21:35 -0500 Subject: [PATCH 21/46] Work towards Windows --- cmake/ADIOSBisonFlexSub.cmake | 2 +- source/adios2/CMakeLists.txt | 2 + source/adios2/toolkit/derived/parser/lexer.l | 10 +- .../pregen-source/{ => Linux}/lexer.cpp | 0 .../parser/pregen-source/{ => Linux}/lexer.h | 0 .../pregen-source/{ => Linux}/location.hh | 0 .../pregen-source/{ => Linux}/parser.cpp | 0 .../parser/pregen-source/{ => Linux}/parser.h | 0 .../parser/pregen-source/Windows/lexer.cpp | 1905 +++++++++++++++++ .../parser/pregen-source/Windows/lexer.h | 477 +++++ .../parser/pregen-source/Windows/location.hh | 306 +++ .../parser/pregen-source/Windows/parser.cpp | 1414 ++++++++++++ .../parser/pregen-source/Windows/parser.h | 1626 ++++++++++++++ 13 files changed, 5740 insertions(+), 2 deletions(-) rename source/adios2/toolkit/derived/parser/pregen-source/{ => Linux}/lexer.cpp (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{ => Linux}/lexer.h (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{ => Linux}/location.hh (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{ => Linux}/parser.cpp (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{ => Linux}/parser.h (100%) create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.h create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp create mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h diff --git a/cmake/ADIOSBisonFlexSub.cmake b/cmake/ADIOSBisonFlexSub.cmake index 0d89e8b823..f2f2f50a04 100644 --- a/cmake/ADIOSBisonFlexSub.cmake +++ b/cmake/ADIOSBisonFlexSub.cmake @@ -2,7 +2,7 @@ FUNCTION (SETUP_ADIOS_BISON_FLEX_SUB) IF ((${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") OR (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")) - set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source") + set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source/Linux") elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Windows") set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source/Windows") else() diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index df0416408b..dd08f8e56b 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -147,9 +147,11 @@ if (ADIOS2_HAVE_Derived_Variable) BISON_TARGET(MyParser toolkit/derived/parser/parser.y ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp + COMPILE_FLAGS "-o parser.cpp --header=parser.h" DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/parser.h) FLEX_TARGET(MyScanner toolkit/derived/parser/lexer.l + COMPILE_FLAGS "-o lexer.cpp --header-file=lexer.h" ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/lexer.h) ADD_FLEX_BISON_DEPENDENCY(MyScanner MyParser) diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index 45386646c0..cee069ec30 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -1,11 +1,19 @@ %{ #include -#include #include #include // strerror #include #include "ASTDriver.h" #include "parser.h" +#if defined(_MSC_VER) +#include +#define YY_NO_UNISTD_H +#define strdup _strdup +#define isatty _isatty +#define fileno _fileno +#include +#include +#endif %} %{ diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.cpp similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp rename to source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.cpp diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.h similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/lexer.h rename to source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.h diff --git a/source/adios2/toolkit/derived/parser/pregen-source/location.hh b/source/adios2/toolkit/derived/parser/pregen-source/Linux/location.hh similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/location.hh rename to source/adios2/toolkit/derived/parser/pregen-source/Linux/location.hh diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.cpp similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/parser.cpp rename to source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.cpp diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.h similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/parser.h rename to source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.h diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp new file mode 100644 index 0000000000..61b3f506af --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp @@ -0,0 +1,1905 @@ +#line 1 "lexer.cpp" + +#line 3 "lexer.cpp" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Returned upon end-of-file. */ +#define YY_NULL 0 + +/* Promotes a possibly negative, possibly signed char to an + * integer in range [0..255] for use as an array index. + */ +#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) + +/* Enter a start condition. This macro really ought to take a parameter, + * but we do it the disgusting crufty way forced on us by the ()-less + * definition of BEGIN. + */ +#define BEGIN (yy_start) = 1 + 2 * +/* Translate the current start state into a value that can be later handed + * to BEGIN to return to the state. The YYSTATE alias is for lex + * compatibility. + */ +#define YY_START (((yy_start) - 1) / 2) +#define YYSTATE YY_START +/* Action number for EOF rule of a given start state. */ +#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) +/* Special action meaning "start processing a new file". */ +#define YY_NEW_FILE yyrestart( yyin ) +#define YY_END_OF_BUFFER_CHAR 0 + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +/* The state buf must be large enough to hold one state per character in the main buffer. + */ +#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#define EOB_ACT_CONTINUE_SCAN 0 +#define EOB_ACT_END_OF_FILE 1 +#define EOB_ACT_LAST_MATCH 2 + + #define YY_LESS_LINENO(n) + #define YY_LINENO_REWIND_TO(ptr) + +/* Return all but the first "n" matched characters back to the input stream. */ +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + *yy_cp = (yy_hold_char); \ + YY_RESTORE_YY_MORE_OFFSET \ + (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ + YY_DO_BEFORE_ACTION; /* set up yytext again */ \ + } \ + while ( 0 ) +#define unput(c) yyunput( c, (yytext_ptr) ) + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + +#define YY_BUFFER_NEW 0 +#define YY_BUFFER_NORMAL 1 + /* When an EOF's been seen but there's still some text to process + * then we mark the buffer as YY_EOF_PENDING, to indicate that we + * shouldn't try reading from the input source any more. We might + * still have a bunch of tokens to match, though, because of + * possible backing-up. + * + * When we actually see the EOF, we change the status to "new" + * (via yyrestart()), so that the user can continue scanning by + * just pointing yyin at a new input file. + */ +#define YY_BUFFER_EOF_PENDING 2 + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +/* Stack of input buffers. */ +static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ +static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ +static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ + +/* We provide macros for accessing buffer states in case in the + * future we want to put the buffer states in a more general + * "scanner state". + * + * Returns the top of the stack, or NULL. + */ +#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ + ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ + : NULL) +/* Same as previous macro, but useful when we know that the buffer stack is not + * NULL or when we need an lvalue. For internal use only. + */ +#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] + +/* yy_hold_char holds the character lost when yytext is formed. */ +static char yy_hold_char; +static int yy_n_chars; /* number of characters read into yy_ch_buf */ +int yyleng; + +/* Points to current character in buffer. */ +static char *yy_c_buf_p = NULL; +static int yy_init = 0; /* whether we need to initialize */ +static int yy_start = 0; /* start state number */ + +/* Flag which is used to allow yywrap()'s to do buffer switches + * instead of setting up a fresh yyin. A bit of a hack ... + */ +static int yy_did_buffer_switch_on_eof; + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +static void yyensure_buffer_stack ( void ); +static void yy_load_buffer_state ( void ); +static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); +#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +#define yy_new_buffer yy_create_buffer +#define yy_set_interactive(is_interactive) \ + { \ + if ( ! YY_CURRENT_BUFFER ){ \ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ + } +#define yy_set_bol(at_bol) \ + { \ + if ( ! YY_CURRENT_BUFFER ){\ + yyensure_buffer_stack (); \ + YY_CURRENT_BUFFER_LVALUE = \ + yy_create_buffer( yyin, YY_BUF_SIZE ); \ + } \ + YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ + } +#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) + +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP +typedef flex_uint8_t YY_CHAR; + +FILE *yyin = NULL, *yyout = NULL; + +typedef int yy_state_type; + +extern int yylineno; +int yylineno = 1; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +static yy_state_type yy_get_previous_state ( void ); +static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); +static int yy_get_next_buffer ( void ); +static void yynoreturn yy_fatal_error ( const char* msg ); + +/* Done after the current pattern has been matched and before the + * corresponding action - sets up yytext. + */ +#define YY_DO_BEFORE_ACTION \ + (yytext_ptr) = yy_bp; \ + yyleng = (int) (yy_cp - yy_bp); \ + (yy_hold_char) = *yy_cp; \ + *yy_cp = '\0'; \ + (yy_c_buf_p) = yy_cp; +#define YY_NUM_RULES 15 +#define YY_END_OF_BUFFER 16 +/* This struct is not used in this scanner, + but its presence is necessary. */ +struct yy_trans_info + { + flex_int32_t yy_verify; + flex_int32_t yy_nxt; + }; +static const flex_int16_t yy_accept[23] = + { 0, + 0, 0, 16, 14, 1, 2, 6, 7, 11, 4, + 10, 5, 3, 12, 8, 9, 1, 2, 10, 13, + 12, 0 + } ; + +static const YY_CHAR yy_ec[256] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, + 5, 6, 6, 7, 8, 9, 8, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 11, 1, 1, + 12, 1, 1, 1, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 14, 9, 15, 6, 16, 1, 13, 13, 13, 13, + + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, + 13, 13, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1 + } ; + +static const YY_CHAR yy_meta[17] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, + 1, 1, 2, 1, 1, 2 + } ; + +static const flex_int16_t yy_base[25] = + { 0, + 0, 0, 29, 30, 26, 24, 30, 30, 30, 30, + 16, 30, 30, 9, 30, 30, 23, 21, 13, 0, + 11, 30, 20, 19 + } ; + +static const flex_int16_t yy_def[25] = + { 0, + 22, 1, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 23, 22, 22, 22, 22, 22, 24, + 23, 0, 22, 22 + } ; + +static const flex_int16_t yy_nxt[47] = + { 0, + 4, 5, 6, 7, 8, 9, 10, 9, 4, 11, + 12, 13, 14, 15, 16, 4, 20, 20, 20, 20, + 20, 21, 19, 18, 17, 19, 18, 17, 22, 3, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22 + } ; + +static const flex_int16_t yy_chk[47] = + { 0, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 14, 14, 21, 21, + 24, 23, 19, 18, 17, 11, 6, 5, 3, 22, + 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, + 22, 22, 22, 22, 22, 22 + } ; + +static yy_state_type yy_last_accepting_state; +static char *yy_last_accepting_cpos; + +extern int yy_flex_debug; +int yy_flex_debug = 0; + +/* The intent behind this definition is that it'll catch + * any uses of REJECT which flex missed. + */ +#define REJECT reject_used_but_not_detected +#define yymore() yymore_used_but_not_detected +#define YY_MORE_ADJ 0 +#define YY_RESTORE_YY_MORE_OFFSET +char *yytext; +#line 1 "lexer.l" +#line 2 "lexer.l" +#include +#include +#include // strerror +#include +#include "ASTDriver.h" +#include "parser.h" +#if defined(_MSC_VER) +#include +#define YY_NO_UNISTD_H +#define strdup _strdup +#define isatty _isatty +#define fileno _fileno +#include +#include +#endif +#line 475 "lexer.cpp" +#line 20 "lexer.l" +#if defined __clang__ +# define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) +#endif + +// Clang and ICC like to pretend they are GCC. +#if defined __GNUC__ && !defined __clang__ && !defined __ICC +# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) +#endif + +// Pacify warnings in yy_init_buffer (observed with Flex 2.6.4) +// and GCC 6.4.0, 7.3.0 with -O3. +#if defined GCC_VERSION && 600 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wnull-dereference" +#endif + +// This example uses Flex's C back end, yet compiles it as C++. +// So expect warnings about C style casts and NULL. +#if defined CLANG_VERSION && 500 <= CLANG_VERSION +# pragma clang diagnostic ignored "-Wold-style-cast" +# pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" +#elif defined GCC_VERSION && 407 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wold-style-cast" +# pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" +#endif + +#define FLEX_VERSION (YY_FLEX_MAJOR_VERSION * 100 + YY_FLEX_MINOR_VERSION) + +// Old versions of Flex (2.5.35) generate an incomplete documentation comment. +// +// In file included from src/scan-code-c.c:3: +// src/scan-code.c:2198:21: error: empty paragraph passed to '@param' command +// [-Werror,-Wdocumentation] +// * @param line_number +// ~~~~~~~~~~~~~~~~~^ +// 1 error generated. +#if FLEX_VERSION < 206 && defined CLANG_VERSION +# pragma clang diagnostic ignored "-Wdocumentation" +#endif + +// Old versions of Flex (2.5.35) use 'register'. Warnings introduced in +// GCC 7 and Clang 6. +#if FLEX_VERSION < 206 +# if defined CLANG_VERSION && 600 <= CLANG_VERSION +# pragma clang diagnostic ignored "-Wdeprecated-register" +# elif defined GCC_VERSION && 700 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wregister" +# endif +#endif + +#if FLEX_VERSION < 206 +# if defined CLANG_VERSION +# pragma clang diagnostic ignored "-Wconversion" +# pragma clang diagnostic ignored "-Wdocumentation" +# pragma clang diagnostic ignored "-Wshorten-64-to-32" +# pragma clang diagnostic ignored "-Wsign-conversion" +# elif defined GCC_VERSION +# pragma GCC diagnostic ignored "-Wconversion" +# pragma GCC diagnostic ignored "-Wsign-conversion" +# endif +#endif + +// Flex 2.6.4, GCC 9 +// warning: useless cast to type 'int' [-Wuseless-cast] +// 1361 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); +// | ^ +#if defined GCC_VERSION && 900 <= GCC_VERSION +# pragma GCC diagnostic ignored "-Wuseless-cast" +#endif +#line 545 "lexer.cpp" +#define YY_NO_INPUT 1 +#line 93 "lexer.l" + // A number symbol corresponding to the value in S. + adios2::detail::parser::symbol_type + make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); +#line 551 "lexer.cpp" +#line 105 "lexer.l" + // Code run each time a pattern is matched. + # define YY_USER_ACTION loc.columns (yyleng); +#line 555 "lexer.cpp" +#line 556 "lexer.cpp" + +#define INITIAL 0 + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +static int yy_init_globals ( void ); + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef YY_NO_UNPUT + +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus +static int yyinput ( void ); +#else +static int input ( void ); +#endif + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Copy whatever the last rule matched to the standard output. */ +#ifndef ECHO +/* This used to be an fputs(), but since the string might contain NUL's, + * we now use fwrite(). + */ +#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) +#endif + +/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, + * is returned in "result". + */ +#ifndef YY_INPUT +#define YY_INPUT(buf,result,max_size) \ + if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ + { \ + int c = '*'; \ + int n; \ + for ( n = 0; n < max_size && \ + (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ + buf[n] = (char) c; \ + if ( c == '\n' ) \ + buf[n++] = (char) c; \ + if ( c == EOF && ferror( yyin ) ) \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + result = n; \ + } \ + else \ + { \ + errno=0; \ + while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ + { \ + if( errno != EINTR) \ + { \ + YY_FATAL_ERROR( "input in flex scanner failed" ); \ + break; \ + } \ + errno=0; \ + clearerr(yyin); \ + } \ + }\ +\ + +#endif + +/* No semi-colon after return; correct usage is to write "yyterminate();" - + * we don't want an extra ';' after the "return" because that will cause + * some compilers to complain about unreachable statements. + */ +#ifndef yyterminate +#define yyterminate() return YY_NULL +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Report a fatal error. */ +#ifndef YY_FATAL_ERROR +#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) +#endif + +/* end tables serialization structures and prototypes */ + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* Code executed at the beginning of each rule, after yytext and yyleng + * have been set up. + */ +#ifndef YY_USER_ACTION +#define YY_USER_ACTION +#endif + +/* Code executed at the end of each rule. */ +#ifndef YY_BREAK +#define YY_BREAK /*LINTED*/break; +#endif + +#define YY_RULE_SETUP \ + YY_USER_ACTION + +/** The main scanner function which does all the work. + */ +YY_DECL +{ + yy_state_type yy_current_state; + char *yy_cp, *yy_bp; + int yy_act; + + if ( !(yy_init) ) + { + (yy_init) = 1; + +#ifdef YY_USER_INIT + YY_USER_INIT; +#endif + + if ( ! (yy_start) ) + (yy_start) = 1; /* first start state */ + + if ( ! yyin ) + yyin = stdin; + + if ( ! yyout ) + yyout = stdout; + + if ( ! YY_CURRENT_BUFFER ) { + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_load_buffer_state( ); + } + + { +#line 108 "lexer.l" + + +#line 111 "lexer.l" + // A handy shortcut to the location held by the adios2::detail::ASTDriver. + adios2::detail::location& loc = drv.location; + // Code run each time yylex is called. + loc.step (); + +#line 780 "lexer.cpp" + + while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ + { + yy_cp = (yy_c_buf_p); + + /* Support of yytext. */ + *yy_cp = (yy_hold_char); + + /* yy_bp points to the position in yy_ch_buf of the start of + * the current run. + */ + yy_bp = yy_cp; + + yy_current_state = (yy_start); +yy_match: + do + { + YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 23 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + ++yy_cp; + } + while ( yy_current_state != 22 ); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + +yy_find_action: + yy_act = yy_accept[yy_current_state]; + + YY_DO_BEFORE_ACTION; + +do_action: /* This label is used only to access EOF actions. */ + + switch ( yy_act ) + { /* beginning of action switch */ + case 0: /* must back up */ + /* undo the effects of YY_DO_BEFORE_ACTION */ + *yy_cp = (yy_hold_char); + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + +case 1: +YY_RULE_SETUP +#line 116 "lexer.l" +loc.step (); + YY_BREAK +case 2: +/* rule 2 can match eol */ +YY_RULE_SETUP +#line 117 "lexer.l" +loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); + YY_BREAK +case 3: +YY_RULE_SETUP +#line 119 "lexer.l" +return adios2::detail::parser::make_ASSIGN (loc); + YY_BREAK +case 4: +YY_RULE_SETUP +#line 120 "lexer.l" +return adios2::detail::parser::make_COMMA (loc); + YY_BREAK +case 5: +YY_RULE_SETUP +#line 121 "lexer.l" +return adios2::detail::parser::make_COLON (loc); + YY_BREAK +case 6: +YY_RULE_SETUP +#line 122 "lexer.l" +return adios2::detail::parser::make_L_PAREN (loc); + YY_BREAK +case 7: +YY_RULE_SETUP +#line 123 "lexer.l" +return adios2::detail::parser::make_R_PAREN (loc); + YY_BREAK +case 8: +YY_RULE_SETUP +#line 124 "lexer.l" +return adios2::detail::parser::make_L_BRACE (loc); + YY_BREAK +case 9: +YY_RULE_SETUP +#line 125 "lexer.l" +return adios2::detail::parser::make_R_BRACE (loc); + YY_BREAK +case 10: +YY_RULE_SETUP +#line 127 "lexer.l" +return make_INT (yytext, loc); + YY_BREAK +case 11: +YY_RULE_SETUP +#line 128 "lexer.l" +return adios2::detail::parser::make_OPERATOR (yytext, loc); + YY_BREAK +case 12: +YY_RULE_SETUP +#line 129 "lexer.l" +return adios2::detail::parser::make_IDENTIFIER (yytext, loc); + YY_BREAK +case 13: +YY_RULE_SETUP +#line 130 "lexer.l" +return adios2::detail::parser::make_VARNAME (yytext, loc); + YY_BREAK +case 14: +YY_RULE_SETUP +#line 131 "lexer.l" +{ + throw adios2::detail::parser::syntax_error + (loc, "invalid character: " + std::string(yytext)); +} + YY_BREAK +case YY_STATE_EOF(INITIAL): +#line 135 "lexer.l" +return adios2::detail::parser::make_YYEOF (loc); + YY_BREAK +case 15: +YY_RULE_SETUP +#line 136 "lexer.l" +ECHO; + YY_BREAK +#line 916 "lexer.cpp" + + case YY_END_OF_BUFFER: + { + /* Amount of text matched not including the EOB char. */ + int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; + + /* Undo the effects of YY_DO_BEFORE_ACTION. */ + *yy_cp = (yy_hold_char); + YY_RESTORE_YY_MORE_OFFSET + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) + { + /* We're scanning a new file or input source. It's + * possible that this happened because the user + * just pointed yyin at a new source and called + * yylex(). If so, then we have to assure + * consistency between YY_CURRENT_BUFFER and our + * globals. Here is the right place to do so, because + * this is the first action (other than possibly a + * back-up) that will match for the new input source. + */ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; + } + + /* Note that here we test for yy_c_buf_p "<=" to the position + * of the first EOB in the buffer, since yy_c_buf_p will + * already have been incremented past the NUL character + * (since all states make transitions on EOB to the + * end-of-buffer state). Contrast this with the test + * in input(). + */ + if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + { /* This was really a NUL. */ + yy_state_type yy_next_state; + + (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + /* Okay, we're now positioned to make the NUL + * transition. We couldn't have + * yy_get_previous_state() go ahead and do it + * for us because it doesn't know how to deal + * with the possibility of jamming (and we don't + * want to build jamming into it because then it + * will run more slowly). + */ + + yy_next_state = yy_try_NUL_trans( yy_current_state ); + + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + + if ( yy_next_state ) + { + /* Consume the NUL. */ + yy_cp = ++(yy_c_buf_p); + yy_current_state = yy_next_state; + goto yy_match; + } + + else + { + yy_cp = (yy_last_accepting_cpos); + yy_current_state = (yy_last_accepting_state); + goto yy_find_action; + } + } + + else switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_END_OF_FILE: + { + (yy_did_buffer_switch_on_eof) = 0; + + if ( yywrap( ) ) + { + /* Note: because we've taken care in + * yy_get_next_buffer() to have set up + * yytext, we can now set up + * yy_c_buf_p so that if some total + * hoser (like flex itself) wants to + * call the scanner after we return the + * YY_NULL, it'll still work - another + * YY_NULL will get returned. + */ + (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; + + yy_act = YY_STATE_EOF(YY_START); + goto do_action; + } + + else + { + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; + } + break; + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = + (yytext_ptr) + yy_amount_of_matched_text; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_match; + + case EOB_ACT_LAST_MATCH: + (yy_c_buf_p) = + &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; + + yy_current_state = yy_get_previous_state( ); + + yy_cp = (yy_c_buf_p); + yy_bp = (yytext_ptr) + YY_MORE_ADJ; + goto yy_find_action; + } + break; + } + + default: + YY_FATAL_ERROR( + "fatal flex scanner internal error--no action found" ); + } /* end of action switch */ + } /* end of scanning one token */ + } /* end of user's declarations */ +} /* end of yylex */ + +/* yy_get_next_buffer - try to read in a new buffer + * + * Returns a code representing an action: + * EOB_ACT_LAST_MATCH - + * EOB_ACT_CONTINUE_SCAN - continue scanning from current position + * EOB_ACT_END_OF_FILE - end of file + */ +static int yy_get_next_buffer (void) +{ + char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; + char *source = (yytext_ptr); + int number_to_move, i; + int ret_val; + + if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) + YY_FATAL_ERROR( + "fatal flex scanner internal error--end of buffer missed" ); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) + { /* Don't try to fill the buffer, so this is an EOF. */ + if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) + { + /* We matched a single character, the EOB, so + * treat this as a final EOF. + */ + return EOB_ACT_END_OF_FILE; + } + + else + { + /* We matched some text prior to the EOB, first + * process it. + */ + return EOB_ACT_LAST_MATCH; + } + } + + /* Try to read more data. */ + + /* First move last chars to start of buffer. */ + number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); + + for ( i = 0; i < number_to_move; ++i ) + *(dest++) = *(source++); + + if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) + /* don't do the read, it's not guaranteed to return an EOF, + * just force an EOF + */ + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; + + else + { + int num_to_read = + YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; + + while ( num_to_read <= 0 ) + { /* Not enough room in the buffer - grow it. */ + + /* just a shorter name for the current buffer */ + YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; + + int yy_c_buf_p_offset = + (int) ((yy_c_buf_p) - b->yy_ch_buf); + + if ( b->yy_is_our_buffer ) + { + int new_size = b->yy_buf_size * 2; + + if ( new_size <= 0 ) + b->yy_buf_size += b->yy_buf_size / 8; + else + b->yy_buf_size *= 2; + + b->yy_ch_buf = (char *) + /* Include room in for 2 EOB chars. */ + yyrealloc( (void *) b->yy_ch_buf, + (yy_size_t) (b->yy_buf_size + 2) ); + } + else + /* Can't grow it, we don't own it. */ + b->yy_ch_buf = NULL; + + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( + "fatal error - scanner input buffer overflow" ); + + (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; + + num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - + number_to_move - 1; + + } + + if ( num_to_read > YY_READ_BUF_SIZE ) + num_to_read = YY_READ_BUF_SIZE; + + /* Read in more data. */ + YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), + (yy_n_chars), num_to_read ); + + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + if ( (yy_n_chars) == 0 ) + { + if ( number_to_move == YY_MORE_ADJ ) + { + ret_val = EOB_ACT_END_OF_FILE; + yyrestart( yyin ); + } + + else + { + ret_val = EOB_ACT_LAST_MATCH; + YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = + YY_BUFFER_EOF_PENDING; + } + } + + else + ret_val = EOB_ACT_CONTINUE_SCAN; + + if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { + /* Extend the array by 50%, plus the number we really need. */ + int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( + (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); + if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); + /* "- 2" to take care of EOB's */ + YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); + } + + (yy_n_chars) += number_to_move; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; + YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; + + (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; + + return ret_val; +} + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + + static yy_state_type yy_get_previous_state (void) +{ + yy_state_type yy_current_state; + char *yy_cp; + + yy_current_state = (yy_start); + + for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) + { + YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 23 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + } + + return yy_current_state; +} + +/* yy_try_NUL_trans - try to make a transition on the NUL character + * + * synopsis + * next_state = yy_try_NUL_trans( current_state ); + */ + static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) +{ + int yy_is_jam; + char *yy_cp = (yy_c_buf_p); + + YY_CHAR yy_c = 1; + if ( yy_accept[yy_current_state] ) + { + (yy_last_accepting_state) = yy_current_state; + (yy_last_accepting_cpos) = yy_cp; + } + while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) + { + yy_current_state = (int) yy_def[yy_current_state]; + if ( yy_current_state >= 23 ) + yy_c = yy_meta[yy_c]; + } + yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; + yy_is_jam = (yy_current_state == 22); + + return yy_is_jam ? 0 : yy_current_state; +} + +#ifndef YY_NO_UNPUT + +#endif + +#ifndef YY_NO_INPUT +#ifdef __cplusplus + static int yyinput (void) +#else + static int input (void) +#endif + +{ + int c; + + *(yy_c_buf_p) = (yy_hold_char); + + if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) + { + /* yy_c_buf_p now points to the character we want to return. + * If this occurs *before* the EOB characters, then it's a + * valid NUL; if not, then we've hit the end of the buffer. + */ + if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) + /* This was really a NUL. */ + *(yy_c_buf_p) = '\0'; + + else + { /* need more input */ + int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + ++(yy_c_buf_p); + + switch ( yy_get_next_buffer( ) ) + { + case EOB_ACT_LAST_MATCH: + /* This happens because yy_g_n_b() + * sees that we've accumulated a + * token and flags that we need to + * try matching the token before + * proceeding. But for input(), + * there's no matching to consider. + * So convert the EOB_ACT_LAST_MATCH + * to EOB_ACT_END_OF_FILE. + */ + + /* Reset buffer status. */ + yyrestart( yyin ); + + /*FALLTHROUGH*/ + + case EOB_ACT_END_OF_FILE: + { + if ( yywrap( ) ) + return 0; + + if ( ! (yy_did_buffer_switch_on_eof) ) + YY_NEW_FILE; +#ifdef __cplusplus + return yyinput(); +#else + return input(); +#endif + } + + case EOB_ACT_CONTINUE_SCAN: + (yy_c_buf_p) = (yytext_ptr) + offset; + break; + } + } + } + + c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ + *(yy_c_buf_p) = '\0'; /* preserve yytext */ + (yy_hold_char) = *++(yy_c_buf_p); + + return c; +} +#endif /* ifndef YY_NO_INPUT */ + +/** Immediately switch to a different input stream. + * @param input_file A readable stream. + * + * @note This function does not reset the start condition to @c INITIAL . + */ + void yyrestart (FILE * input_file ) +{ + + if ( ! YY_CURRENT_BUFFER ){ + yyensure_buffer_stack (); + YY_CURRENT_BUFFER_LVALUE = + yy_create_buffer( yyin, YY_BUF_SIZE ); + } + + yy_init_buffer( YY_CURRENT_BUFFER, input_file ); + yy_load_buffer_state( ); +} + +/** Switch to a different input buffer. + * @param new_buffer The new input buffer. + * + */ + void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) +{ + + /* TODO. We should be able to replace this entire function body + * with + * yypop_buffer_state(); + * yypush_buffer_state(new_buffer); + */ + yyensure_buffer_stack (); + if ( YY_CURRENT_BUFFER == new_buffer ) + return; + + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + YY_CURRENT_BUFFER_LVALUE = new_buffer; + yy_load_buffer_state( ); + + /* We don't actually know whether we did this switch during + * EOF (yywrap()) processing, but the only time this flag + * is looked at is after yywrap() is called, so it's safe + * to go ahead and always set it. + */ + (yy_did_buffer_switch_on_eof) = 1; +} + +static void yy_load_buffer_state (void) +{ + (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; + (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; + yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; + (yy_hold_char) = *(yy_c_buf_p); +} + +/** Allocate and initialize an input buffer state. + * @param file A readable stream. + * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. + * + * @return the allocated buffer state. + */ + YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) +{ + YY_BUFFER_STATE b; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_buf_size = size; + + /* yy_ch_buf has to be 2 characters longer than the size given because + * we need to put in 2 end-of-buffer characters. + */ + b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); + if ( ! b->yy_ch_buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); + + b->yy_is_our_buffer = 1; + + yy_init_buffer( b, file ); + + return b; +} + +/** Destroy the buffer. + * @param b a buffer created with yy_create_buffer() + * + */ + void yy_delete_buffer (YY_BUFFER_STATE b ) +{ + + if ( ! b ) + return; + + if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ + YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; + + if ( b->yy_is_our_buffer ) + yyfree( (void *) b->yy_ch_buf ); + + yyfree( (void *) b ); +} + +/* Initializes or reinitializes a buffer. + * This function is sometimes called more than once on the same buffer, + * such as during a yyrestart() or at EOF. + */ + static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) + +{ + int oerrno = errno; + + yy_flush_buffer( b ); + + b->yy_input_file = file; + b->yy_fill_buffer = 1; + + /* If b is the current buffer, then yy_init_buffer was _probably_ + * called from yyrestart() or through yy_get_next_buffer. + * In that case, we don't want to reset the lineno or column. + */ + if (b != YY_CURRENT_BUFFER){ + b->yy_bs_lineno = 1; + b->yy_bs_column = 0; + } + + b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; + + errno = oerrno; +} + +/** Discard all buffered characters. On the next scan, YY_INPUT will be called. + * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. + * + */ + void yy_flush_buffer (YY_BUFFER_STATE b ) +{ + if ( ! b ) + return; + + b->yy_n_chars = 0; + + /* We always need two end-of-buffer characters. The first causes + * a transition to the end-of-buffer state. The second causes + * a jam in that state. + */ + b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; + b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; + + b->yy_buf_pos = &b->yy_ch_buf[0]; + + b->yy_at_bol = 1; + b->yy_buffer_status = YY_BUFFER_NEW; + + if ( b == YY_CURRENT_BUFFER ) + yy_load_buffer_state( ); +} + +/** Pushes the new state onto the stack. The new state becomes + * the current state. This function will allocate the stack + * if necessary. + * @param new_buffer The new state. + * + */ +void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) +{ + if (new_buffer == NULL) + return; + + yyensure_buffer_stack(); + + /* This block is copied from yy_switch_to_buffer. */ + if ( YY_CURRENT_BUFFER ) + { + /* Flush out information for old buffer. */ + *(yy_c_buf_p) = (yy_hold_char); + YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); + YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); + } + + /* Only push if top exists. Otherwise, replace top. */ + if (YY_CURRENT_BUFFER) + (yy_buffer_stack_top)++; + YY_CURRENT_BUFFER_LVALUE = new_buffer; + + /* copied from yy_switch_to_buffer. */ + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; +} + +/** Removes and deletes the top of the stack, if present. + * The next element becomes the new top. + * + */ +void yypop_buffer_state (void) +{ + if (!YY_CURRENT_BUFFER) + return; + + yy_delete_buffer(YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + if ((yy_buffer_stack_top) > 0) + --(yy_buffer_stack_top); + + if (YY_CURRENT_BUFFER) { + yy_load_buffer_state( ); + (yy_did_buffer_switch_on_eof) = 1; + } +} + +/* Allocates the stack if it does not exist. + * Guarantees space for at least one push. + */ +static void yyensure_buffer_stack (void) +{ + yy_size_t num_to_alloc; + + if (!(yy_buffer_stack)) { + + /* First allocation is just for 2 elements, since we don't know if this + * scanner will even need a stack. We use 2 instead of 1 to avoid an + * immediate realloc on the next call. + */ + num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ + (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc + (num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); + + (yy_buffer_stack_max) = num_to_alloc; + (yy_buffer_stack_top) = 0; + return; + } + + if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ + + /* Increase the buffer to prepare for a possible push. */ + yy_size_t grow_size = 8 /* arbitrary grow size */; + + num_to_alloc = (yy_buffer_stack_max) + grow_size; + (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc + ((yy_buffer_stack), + num_to_alloc * sizeof(struct yy_buffer_state*) + ); + if ( ! (yy_buffer_stack) ) + YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); + + /* zero only the new slots.*/ + memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); + (yy_buffer_stack_max) = num_to_alloc; + } +} + +/** Setup the input buffer state to scan directly from a user-specified character buffer. + * @param base the character buffer + * @param size the size in bytes of the character buffer + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) +{ + YY_BUFFER_STATE b; + + if ( size < 2 || + base[size-2] != YY_END_OF_BUFFER_CHAR || + base[size-1] != YY_END_OF_BUFFER_CHAR ) + /* They forgot to leave room for the EOB's. */ + return NULL; + + b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); + if ( ! b ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); + + b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ + b->yy_buf_pos = b->yy_ch_buf = base; + b->yy_is_our_buffer = 0; + b->yy_input_file = NULL; + b->yy_n_chars = b->yy_buf_size; + b->yy_is_interactive = 0; + b->yy_at_bol = 1; + b->yy_fill_buffer = 0; + b->yy_buffer_status = YY_BUFFER_NEW; + + yy_switch_to_buffer( b ); + + return b; +} + +/** Setup the input buffer state to scan a string. The next call to yylex() will + * scan from a @e copy of @a str. + * @param yystr a NUL-terminated string to scan + * + * @return the newly allocated buffer state object. + * @note If you want to scan bytes that may contain NUL values, then use + * yy_scan_bytes() instead. + */ +YY_BUFFER_STATE yy_scan_string (const char * yystr ) +{ + + return yy_scan_bytes( yystr, (int) strlen(yystr) ); +} + +/** Setup the input buffer state to scan the given bytes. The next call to yylex() will + * scan from a @e copy of @a bytes. + * @param yybytes the byte buffer to scan + * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. + * + * @return the newly allocated buffer state object. + */ +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +{ + YY_BUFFER_STATE b; + char *buf; + yy_size_t n; + int i; + + /* Get memory for full buffer, including space for trailing EOB's. */ + n = (yy_size_t) (_yybytes_len + 2); + buf = (char *) yyalloc( n ); + if ( ! buf ) + YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); + + for ( i = 0; i < _yybytes_len; ++i ) + buf[i] = yybytes[i]; + + buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; + + b = yy_scan_buffer( buf, n ); + if ( ! b ) + YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); + + /* It's okay to grow etc. this buffer, and we should throw it + * away when we're done. + */ + b->yy_is_our_buffer = 1; + + return b; +} + +#ifndef YY_EXIT_FAILURE +#define YY_EXIT_FAILURE 2 +#endif + +static void yynoreturn yy_fatal_error (const char* msg ) +{ + fprintf( stderr, "%s\n", msg ); + exit( YY_EXIT_FAILURE ); +} + +/* Redefine yyless() so it works in section 3 code. */ + +#undef yyless +#define yyless(n) \ + do \ + { \ + /* Undo effects of setting up yytext. */ \ + int yyless_macro_arg = (n); \ + YY_LESS_LINENO(yyless_macro_arg);\ + yytext[yyleng] = (yy_hold_char); \ + (yy_c_buf_p) = yytext + yyless_macro_arg; \ + (yy_hold_char) = *(yy_c_buf_p); \ + *(yy_c_buf_p) = '\0'; \ + yyleng = yyless_macro_arg; \ + } \ + while ( 0 ) + +/* Accessor methods (get/set functions) to struct members. */ + +/** Get the current line number. + * + */ +int yyget_lineno (void) +{ + + return yylineno; +} + +/** Get the input stream. + * + */ +FILE *yyget_in (void) +{ + return yyin; +} + +/** Get the output stream. + * + */ +FILE *yyget_out (void) +{ + return yyout; +} + +/** Get the length of the current token. + * + */ +int yyget_leng (void) +{ + return yyleng; +} + +/** Get the current token. + * + */ + +char *yyget_text (void) +{ + return yytext; +} + +/** Set the current line number. + * @param _line_number line number + * + */ +void yyset_lineno (int _line_number ) +{ + + yylineno = _line_number; +} + +/** Set the input stream. This does not discard the current + * input buffer. + * @param _in_str A readable stream. + * + * @see yy_switch_to_buffer + */ +void yyset_in (FILE * _in_str ) +{ + yyin = _in_str ; +} + +void yyset_out (FILE * _out_str ) +{ + yyout = _out_str ; +} + +int yyget_debug (void) +{ + return yy_flex_debug; +} + +void yyset_debug (int _bdebug ) +{ + yy_flex_debug = _bdebug ; +} + +static int yy_init_globals (void) +{ + /* Initialization is the same as for the non-reentrant scanner. + * This function is called from yylex_destroy(), so don't allocate here. + */ + + (yy_buffer_stack) = NULL; + (yy_buffer_stack_top) = 0; + (yy_buffer_stack_max) = 0; + (yy_c_buf_p) = NULL; + (yy_init) = 0; + (yy_start) = 0; + +/* Defined in main.c */ +#ifdef YY_STDINIT + yyin = stdin; + yyout = stdout; +#else + yyin = NULL; + yyout = NULL; +#endif + + /* For future reference: Set errno on error, since we are called by + * yylex_init() + */ + return 0; +} + +/* yylex_destroy is for both reentrant and non-reentrant scanners. */ +int yylex_destroy (void) +{ + + /* Pop the buffer stack, destroying each element. */ + while(YY_CURRENT_BUFFER){ + yy_delete_buffer( YY_CURRENT_BUFFER ); + YY_CURRENT_BUFFER_LVALUE = NULL; + yypop_buffer_state(); + } + + /* Destroy the stack itself. */ + yyfree((yy_buffer_stack) ); + (yy_buffer_stack) = NULL; + + /* Reset the globals. This is important in a non-reentrant scanner so the next time + * yylex() is called, initialization will occur. */ + yy_init_globals( ); + + return 0; +} + +/* + * Internal utility routines. + */ + +#ifndef yytext_ptr +static void yy_flex_strncpy (char* s1, const char * s2, int n ) +{ + + int i; + for ( i = 0; i < n; ++i ) + s1[i] = s2[i]; +} +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen (const char * s ) +{ + int n; + for ( n = 0; s[n]; ++n ) + ; + + return n; +} +#endif + +void *yyalloc (yy_size_t size ) +{ + return malloc(size); +} + +void *yyrealloc (void * ptr, yy_size_t size ) +{ + + /* The cast to (char *) in the following accommodates both + * implementations that use char* generic pointers, and those + * that use void* generic pointers. It works with the latter + * because both ANSI C and C++ allow castless assignment from + * any pointer type to void*, and deal with argument conversions + * as though doing an assignment. + */ + return realloc(ptr, size); +} + +void yyfree (void * ptr ) +{ + free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ +} + +#define YYTABLES_NAME "yytables" + +#line 136 "lexer.l" + + +adios2::detail::parser::symbol_type +make_INT (const std::string &s, const adios2::detail::parser::location_type& loc) +{ + errno = 0; + long n = strtol (s.c_str(), NULL, 10); + if (! (INT_MIN <= n && n <= INT_MAX && errno != ERANGE)) + throw adios2::detail::parser::syntax_error (loc, "integer is out of range: " + s); + return adios2::detail::parser::make_INT ((int) n, loc); +} + +adios2::detail::ASTNode* +adios2::detail::ASTDriver::parse (const std::string input) +{ + adios2::detail::parser parse (*this); + yy_scan_string(input.c_str()); + parse.set_debug_level (trace_parsing); + parse (); + return getAST(); +} + diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.h new file mode 100644 index 0000000000..68b7ab05e3 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.h @@ -0,0 +1,477 @@ +#ifndef yyHEADER_H +#define yyHEADER_H 1 +#define yyIN_HEADER 1 + +#line 5 "lexer.h" + +#line 7 "lexer.h" + +#define YY_INT_ALIGNED short int + +/* A lexical scanner generated by flex */ + +#define FLEX_SCANNER +#define YY_FLEX_MAJOR_VERSION 2 +#define YY_FLEX_MINOR_VERSION 6 +#define YY_FLEX_SUBMINOR_VERSION 4 +#if YY_FLEX_SUBMINOR_VERSION > 0 +#define FLEX_BETA +#endif + +/* First, we deal with platform-specific or compiler-specific issues. */ + +/* begin standard C headers. */ +#include +#include +#include +#include + +/* end standard C headers. */ + +/* flex integer type definitions */ + +#ifndef FLEXINT_H +#define FLEXINT_H + +/* C99 systems have . Non-C99 systems may or may not. */ + +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + +/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, + * if you want the limit (max/min) macros for int types. + */ +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS 1 +#endif + +#include +typedef int8_t flex_int8_t; +typedef uint8_t flex_uint8_t; +typedef int16_t flex_int16_t; +typedef uint16_t flex_uint16_t; +typedef int32_t flex_int32_t; +typedef uint32_t flex_uint32_t; +#else +typedef signed char flex_int8_t; +typedef short int flex_int16_t; +typedef int flex_int32_t; +typedef unsigned char flex_uint8_t; +typedef unsigned short int flex_uint16_t; +typedef unsigned int flex_uint32_t; + +/* Limits of integral types. */ +#ifndef INT8_MIN +#define INT8_MIN (-128) +#endif +#ifndef INT16_MIN +#define INT16_MIN (-32767-1) +#endif +#ifndef INT32_MIN +#define INT32_MIN (-2147483647-1) +#endif +#ifndef INT8_MAX +#define INT8_MAX (127) +#endif +#ifndef INT16_MAX +#define INT16_MAX (32767) +#endif +#ifndef INT32_MAX +#define INT32_MAX (2147483647) +#endif +#ifndef UINT8_MAX +#define UINT8_MAX (255U) +#endif +#ifndef UINT16_MAX +#define UINT16_MAX (65535U) +#endif +#ifndef UINT32_MAX +#define UINT32_MAX (4294967295U) +#endif + +#ifndef SIZE_MAX +#define SIZE_MAX (~(size_t)0) +#endif + +#endif /* ! C99 */ + +#endif /* ! FLEXINT_H */ + +/* begin standard C++ headers. */ + +/* TODO: this is always defined, so inline it */ +#define yyconst const + +#if defined(__GNUC__) && __GNUC__ >= 3 +#define yynoreturn __attribute__((__noreturn__)) +#else +#define yynoreturn +#endif + +/* Size of default input buffer. */ +#ifndef YY_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k. + * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. + * Ditto for the __ia64__ case accordingly. + */ +#define YY_BUF_SIZE 32768 +#else +#define YY_BUF_SIZE 16384 +#endif /* __ia64__ */ +#endif + +#ifndef YY_TYPEDEF_YY_BUFFER_STATE +#define YY_TYPEDEF_YY_BUFFER_STATE +typedef struct yy_buffer_state *YY_BUFFER_STATE; +#endif + +#ifndef YY_TYPEDEF_YY_SIZE_T +#define YY_TYPEDEF_YY_SIZE_T +typedef size_t yy_size_t; +#endif + +extern int yyleng; + +extern FILE *yyin, *yyout; + +#ifndef YY_STRUCT_YY_BUFFER_STATE +#define YY_STRUCT_YY_BUFFER_STATE +struct yy_buffer_state + { + FILE *yy_input_file; + + char *yy_ch_buf; /* input buffer */ + char *yy_buf_pos; /* current position in input buffer */ + + /* Size of input buffer in bytes, not including room for EOB + * characters. + */ + int yy_buf_size; + + /* Number of characters read into yy_ch_buf, not including EOB + * characters. + */ + int yy_n_chars; + + /* Whether we "own" the buffer - i.e., we know we created it, + * and can realloc() it to grow it, and should free() it to + * delete it. + */ + int yy_is_our_buffer; + + /* Whether this is an "interactive" input source; if so, and + * if we're using stdio for input, then we want to use getc() + * instead of fread(), to make sure we stop fetching input after + * each newline. + */ + int yy_is_interactive; + + /* Whether we're considered to be at the beginning of a line. + * If so, '^' rules will be active on the next match, otherwise + * not. + */ + int yy_at_bol; + + int yy_bs_lineno; /**< The line count. */ + int yy_bs_column; /**< The column count. */ + + /* Whether to try to fill the input buffer when we reach the + * end of it. + */ + int yy_fill_buffer; + + int yy_buffer_status; + + }; +#endif /* !YY_STRUCT_YY_BUFFER_STATE */ + +void yyrestart ( FILE *input_file ); +void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); +YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); +void yy_delete_buffer ( YY_BUFFER_STATE b ); +void yy_flush_buffer ( YY_BUFFER_STATE b ); +void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); +void yypop_buffer_state ( void ); + +YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); +YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); + +void *yyalloc ( yy_size_t ); +void *yyrealloc ( void *, yy_size_t ); +void yyfree ( void * ); + +/* Begin user sect3 */ + +#define yywrap() (/*CONSTCOND*/1) +#define YY_SKIP_YYWRAP + +extern int yylineno; + +extern char *yytext; +#ifdef yytext_ptr +#undef yytext_ptr +#endif +#define yytext_ptr yytext + +#ifdef YY_HEADER_EXPORT_START_CONDITIONS +#define INITIAL 0 + +#endif + +#ifndef YY_NO_UNISTD_H +/* Special case for "unistd.h", since it is non-ANSI. We include it way + * down here because we want the user's section 1 to have been scanned first. + * The user has a chance to override it with an option. + */ +#include +#endif + +#ifndef YY_EXTRA_TYPE +#define YY_EXTRA_TYPE void * +#endif + +/* Accessor methods to globals. + These are made visible to non-reentrant scanners for convenience. */ + +int yylex_destroy ( void ); + +int yyget_debug ( void ); + +void yyset_debug ( int debug_flag ); + +YY_EXTRA_TYPE yyget_extra ( void ); + +void yyset_extra ( YY_EXTRA_TYPE user_defined ); + +FILE *yyget_in ( void ); + +void yyset_in ( FILE * _in_str ); + +FILE *yyget_out ( void ); + +void yyset_out ( FILE * _out_str ); + + int yyget_leng ( void ); + +char *yyget_text ( void ); + +int yyget_lineno ( void ); + +void yyset_lineno ( int _line_number ); + +/* Macros after this point can all be overridden by user definitions in + * section 1. + */ + +#ifndef YY_SKIP_YYWRAP +#ifdef __cplusplus +extern "C" int yywrap ( void ); +#else +extern int yywrap ( void ); +#endif +#endif + +#ifndef yytext_ptr +static void yy_flex_strncpy ( char *, const char *, int ); +#endif + +#ifdef YY_NEED_STRLEN +static int yy_flex_strlen ( const char * ); +#endif + +#ifndef YY_NO_INPUT + +#endif + +/* Amount of stuff to slurp up with each read. */ +#ifndef YY_READ_BUF_SIZE +#ifdef __ia64__ +/* On IA-64, the buffer size is 16k, not 8k */ +#define YY_READ_BUF_SIZE 16384 +#else +#define YY_READ_BUF_SIZE 8192 +#endif /* __ia64__ */ +#endif + +/* Number of entries by which start-condition stack grows. */ +#ifndef YY_START_STACK_INCR +#define YY_START_STACK_INCR 25 +#endif + +/* Default declaration of generated scanner - a define so the user can + * easily add parameters. + */ +#ifndef YY_DECL +#define YY_DECL_IS_OURS 1 + +extern int yylex (void); + +#define YY_DECL int yylex (void) +#endif /* !YY_DECL */ + +/* yy_get_previous_state - get the state just before the EOB char was reached */ + +#undef YY_NEW_FILE +#undef YY_FLUSH_BUFFER +#undef yy_set_bol +#undef yy_new_buffer +#undef yy_set_interactive +#undef YY_DO_BEFORE_ACTION + +#ifdef YY_DECL_IS_OURS +#undef YY_DECL_IS_OURS +#undef YY_DECL +#endif + +#ifndef yy_create_buffer_ALREADY_DEFINED +#undef yy_create_buffer +#endif +#ifndef yy_delete_buffer_ALREADY_DEFINED +#undef yy_delete_buffer +#endif +#ifndef yy_scan_buffer_ALREADY_DEFINED +#undef yy_scan_buffer +#endif +#ifndef yy_scan_string_ALREADY_DEFINED +#undef yy_scan_string +#endif +#ifndef yy_scan_bytes_ALREADY_DEFINED +#undef yy_scan_bytes +#endif +#ifndef yy_init_buffer_ALREADY_DEFINED +#undef yy_init_buffer +#endif +#ifndef yy_flush_buffer_ALREADY_DEFINED +#undef yy_flush_buffer +#endif +#ifndef yy_load_buffer_state_ALREADY_DEFINED +#undef yy_load_buffer_state +#endif +#ifndef yy_switch_to_buffer_ALREADY_DEFINED +#undef yy_switch_to_buffer +#endif +#ifndef yypush_buffer_state_ALREADY_DEFINED +#undef yypush_buffer_state +#endif +#ifndef yypop_buffer_state_ALREADY_DEFINED +#undef yypop_buffer_state +#endif +#ifndef yyensure_buffer_stack_ALREADY_DEFINED +#undef yyensure_buffer_stack +#endif +#ifndef yylex_ALREADY_DEFINED +#undef yylex +#endif +#ifndef yyrestart_ALREADY_DEFINED +#undef yyrestart +#endif +#ifndef yylex_init_ALREADY_DEFINED +#undef yylex_init +#endif +#ifndef yylex_init_extra_ALREADY_DEFINED +#undef yylex_init_extra +#endif +#ifndef yylex_destroy_ALREADY_DEFINED +#undef yylex_destroy +#endif +#ifndef yyget_debug_ALREADY_DEFINED +#undef yyget_debug +#endif +#ifndef yyset_debug_ALREADY_DEFINED +#undef yyset_debug +#endif +#ifndef yyget_extra_ALREADY_DEFINED +#undef yyget_extra +#endif +#ifndef yyset_extra_ALREADY_DEFINED +#undef yyset_extra +#endif +#ifndef yyget_in_ALREADY_DEFINED +#undef yyget_in +#endif +#ifndef yyset_in_ALREADY_DEFINED +#undef yyset_in +#endif +#ifndef yyget_out_ALREADY_DEFINED +#undef yyget_out +#endif +#ifndef yyset_out_ALREADY_DEFINED +#undef yyset_out +#endif +#ifndef yyget_leng_ALREADY_DEFINED +#undef yyget_leng +#endif +#ifndef yyget_text_ALREADY_DEFINED +#undef yyget_text +#endif +#ifndef yyget_lineno_ALREADY_DEFINED +#undef yyget_lineno +#endif +#ifndef yyset_lineno_ALREADY_DEFINED +#undef yyset_lineno +#endif +#ifndef yyget_column_ALREADY_DEFINED +#undef yyget_column +#endif +#ifndef yyset_column_ALREADY_DEFINED +#undef yyset_column +#endif +#ifndef yywrap_ALREADY_DEFINED +#undef yywrap +#endif +#ifndef yyget_lval_ALREADY_DEFINED +#undef yyget_lval +#endif +#ifndef yyset_lval_ALREADY_DEFINED +#undef yyset_lval +#endif +#ifndef yyget_lloc_ALREADY_DEFINED +#undef yyget_lloc +#endif +#ifndef yyset_lloc_ALREADY_DEFINED +#undef yyset_lloc +#endif +#ifndef yyalloc_ALREADY_DEFINED +#undef yyalloc +#endif +#ifndef yyrealloc_ALREADY_DEFINED +#undef yyrealloc +#endif +#ifndef yyfree_ALREADY_DEFINED +#undef yyfree +#endif +#ifndef yytext_ALREADY_DEFINED +#undef yytext +#endif +#ifndef yyleng_ALREADY_DEFINED +#undef yyleng +#endif +#ifndef yyin_ALREADY_DEFINED +#undef yyin +#endif +#ifndef yyout_ALREADY_DEFINED +#undef yyout +#endif +#ifndef yy_flex_debug_ALREADY_DEFINED +#undef yy_flex_debug +#endif +#ifndef yylineno_ALREADY_DEFINED +#undef yylineno +#endif +#ifndef yytables_fload_ALREADY_DEFINED +#undef yytables_fload +#endif +#ifndef yytables_destroy_ALREADY_DEFINED +#undef yytables_destroy +#endif +#ifndef yyTABLES_NAME_ALREADY_DEFINED +#undef yyTABLES_NAME +#endif + +#line 136 "lexer.l" + + +#line 475 "lexer.h" +#undef yyIN_HEADER +#endif /* yyHEADER_H */ diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh b/source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh new file mode 100644 index 0000000000..be150130f8 --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh @@ -0,0 +1,306 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Locations for Bison parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + +/** + ** \file location.hh + ** Define the adios2::detail::location class. + */ + +#ifndef YY_YY_LOCATION_HH_INCLUDED +# define YY_YY_LOCATION_HH_INCLUDED + +# include +# include + +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +#line 6 "parser.y" +namespace adios2 { namespace detail { +#line 59 "location.hh" + + /// A point in a source file. + class position + { + public: + /// Type for file name. + typedef const std::string filename_type; + /// Type for line and column numbers. + typedef int counter_type; + + /// Construct a position. + explicit position (filename_type* f = YY_NULLPTR, + counter_type l = 1, + counter_type c = 1) + : filename (f) + , line (l) + , column (c) + {} + + + /// Initialization. + void initialize (filename_type* fn = YY_NULLPTR, + counter_type l = 1, + counter_type c = 1) + { + filename = fn; + line = l; + column = c; + } + + /** \name Line and Column related manipulators + ** \{ */ + /// (line related) Advance to the COUNT next lines. + void lines (counter_type count = 1) + { + if (count) + { + column = 1; + line = add_ (line, count, 1); + } + } + + /// (column related) Advance to the COUNT next columns. + void columns (counter_type count = 1) + { + column = add_ (column, count, 1); + } + /** \} */ + + /// File name to which this position refers. + filename_type* filename; + /// Current line number. + counter_type line; + /// Current column number. + counter_type column; + + private: + /// Compute max (min, lhs+rhs). + static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min) + { + return lhs + rhs < min ? min : lhs + rhs; + } + }; + + /// Add \a width columns, in place. + inline position& + operator+= (position& res, position::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns. + inline position + operator+ (position res, position::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns, in place. + inline position& + operator-= (position& res, position::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns. + inline position + operator- (position res, position::counter_type width) + { + return res -= width; + } + + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param pos a reference to the position to redirect + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const position& pos) + { + if (pos.filename) + ostr << *pos.filename << ':'; + return ostr << pos.line << '.' << pos.column; + } + + /// Two points in a source file. + class location + { + public: + /// Type for file name. + typedef position::filename_type filename_type; + /// Type for line and column numbers. + typedef position::counter_type counter_type; + + /// Construct a location from \a b to \a e. + location (const position& b, const position& e) + : begin (b) + , end (e) + {} + + /// Construct a 0-width location in \a p. + explicit location (const position& p = position ()) + : begin (p) + , end (p) + {} + + /// Construct a 0-width location in \a f, \a l, \a c. + explicit location (filename_type* f, + counter_type l = 1, + counter_type c = 1) + : begin (f, l, c) + , end (f, l, c) + {} + + + /// Initialization. + void initialize (filename_type* f = YY_NULLPTR, + counter_type l = 1, + counter_type c = 1) + { + begin.initialize (f, l, c); + end = begin; + } + + /** \name Line and Column related manipulators + ** \{ */ + public: + /// Reset initial location to final location. + void step () + { + begin = end; + } + + /// Extend the current location to the COUNT next columns. + void columns (counter_type count = 1) + { + end += count; + } + + /// Extend the current location to the COUNT next lines. + void lines (counter_type count = 1) + { + end.lines (count); + } + /** \} */ + + + public: + /// Beginning of the located region. + position begin; + /// End of the located region. + position end; + }; + + /// Join two locations, in place. + inline location& + operator+= (location& res, const location& end) + { + res.end = end.end; + return res; + } + + /// Join two locations. + inline location + operator+ (location res, const location& end) + { + return res += end; + } + + /// Add \a width columns to the end position, in place. + inline location& + operator+= (location& res, location::counter_type width) + { + res.columns (width); + return res; + } + + /// Add \a width columns to the end position. + inline location + operator+ (location res, location::counter_type width) + { + return res += width; + } + + /// Subtract \a width columns to the end position, in place. + inline location& + operator-= (location& res, location::counter_type width) + { + return res += -width; + } + + /// Subtract \a width columns to the end position. + inline location + operator- (location res, location::counter_type width) + { + return res -= width; + } + + /** \brief Intercept output stream redirection. + ** \param ostr the destination output stream + ** \param loc a reference to the location to redirect + ** + ** Avoid duplicate information. + */ + template + std::basic_ostream& + operator<< (std::basic_ostream& ostr, const location& loc) + { + location::counter_type end_col + = 0 < loc.end.column ? loc.end.column - 1 : 0; + ostr << loc.begin; + if (loc.end.filename + && (!loc.begin.filename + || *loc.begin.filename != *loc.end.filename)) + ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; + else if (loc.begin.line < loc.end.line) + ostr << '-' << loc.end.line << '.' << end_col; + else if (loc.begin.column < end_col) + ostr << '-' << end_col; + return ostr; + } + +#line 6 "parser.y" +} } // adios2::detail +#line 305 "location.hh" + +#endif // !YY_YY_LOCATION_HH_INCLUDED diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp new file mode 100644 index 0000000000..9a53a89e3b --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp @@ -0,0 +1,1414 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Skeleton implementation for Bison LALR(1) parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. + + + + + +#include "parser.h" + + +// Unqualified %code blocks. +#line 33 "parser.y" + +#include "ASTDriver.h" +#include "ASTNode.h" + +#line 51 "parser.cpp" + + +#ifndef YY_ +# if defined YYENABLE_NLS && YYENABLE_NLS +# if ENABLE_NLS +# include // FIXME: INFRINGES ON USER NAME SPACE. +# define YY_(msgid) dgettext ("bison-runtime", msgid) +# endif +# endif +# ifndef YY_ +# define YY_(msgid) msgid +# endif +#endif + + +// Whether we are compiled with exception support. +#ifndef YY_EXCEPTIONS +# if defined __GNUC__ && !defined __EXCEPTIONS +# define YY_EXCEPTIONS 0 +# else +# define YY_EXCEPTIONS 1 +# endif +#endif + +#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) +/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. + If N is 0, then set CURRENT to the empty location which ends + the previous symbol: RHS[0] (always defined). */ + +# ifndef YYLLOC_DEFAULT +# define YYLLOC_DEFAULT(Current, Rhs, N) \ + do \ + if (N) \ + { \ + (Current).begin = YYRHSLOC (Rhs, 1).begin; \ + (Current).end = YYRHSLOC (Rhs, N).end; \ + } \ + else \ + { \ + (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ + } \ + while (false) +# endif + + +// Enable debugging if requested. +#if YYDEBUG + +// A pseudo ostream that takes yydebug_ into account. +# define YYCDEBUG if (yydebug_) (*yycdebug_) + +# define YY_SYMBOL_PRINT(Title, Symbol) \ + do { \ + if (yydebug_) \ + { \ + *yycdebug_ << Title << ' '; \ + yy_print_ (*yycdebug_, Symbol); \ + *yycdebug_ << '\n'; \ + } \ + } while (false) + +# define YY_REDUCE_PRINT(Rule) \ + do { \ + if (yydebug_) \ + yy_reduce_print_ (Rule); \ + } while (false) + +# define YY_STACK_PRINT() \ + do { \ + if (yydebug_) \ + yy_stack_print_ (); \ + } while (false) + +#else // !YYDEBUG + +# define YYCDEBUG if (false) std::cerr +# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) +# define YY_REDUCE_PRINT(Rule) static_cast (0) +# define YY_STACK_PRINT() static_cast (0) + +#endif // !YYDEBUG + +#define yyerrok (yyerrstatus_ = 0) +#define yyclearin (yyla.clear ()) + +#define YYACCEPT goto yyacceptlab +#define YYABORT goto yyabortlab +#define YYERROR goto yyerrorlab +#define YYRECOVERING() (!!yyerrstatus_) + +#line 6 "parser.y" +namespace adios2 { namespace detail { +#line 144 "parser.cpp" + + /// Build a parser object. + parser::parser (ASTDriver& drv_yyarg) +#if YYDEBUG + : yydebug_ (false), + yycdebug_ (&std::cerr), +#else + : +#endif + yy_lac_established_ (false), + drv (drv_yyarg) + {} + + parser::~parser () + {} + + parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW + {} + + /*---------. + | symbol. | + `---------*/ + + + + // by_state. + parser::by_state::by_state () YY_NOEXCEPT + : state (empty_state) + {} + + parser::by_state::by_state (const by_state& that) YY_NOEXCEPT + : state (that.state) + {} + + void + parser::by_state::clear () YY_NOEXCEPT + { + state = empty_state; + } + + void + parser::by_state::move (by_state& that) + { + state = that.state; + that.clear (); + } + + parser::by_state::by_state (state_type s) YY_NOEXCEPT + : state (s) + {} + + parser::symbol_kind_type + parser::by_state::kind () const YY_NOEXCEPT + { + if (state == empty_state) + return symbol_kind::S_YYEMPTY; + else + return YY_CAST (symbol_kind_type, yystos_[+state]); + } + + parser::stack_symbol_type::stack_symbol_type () + {} + + parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) + : super_type (YY_MOVE (that.state), YY_MOVE (that.location)) + { + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.YY_MOVE_OR_COPY< int > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_index: // index + value.YY_MOVE_OR_COPY< std::tuple > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.YY_MOVE_OR_COPY< std::vector> > (YY_MOVE (that.value)); + break; + + default: + break; + } + +#if 201103L <= YY_CPLUSPLUS + // that is emptied. + that.state = empty_state; +#endif + } + + parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) + : super_type (s, YY_MOVE (that.location)) + { + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.move< int > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (YY_MOVE (that.value)); + break; + + default: + break; + } + + // that is emptied. + that.kind_ = symbol_kind::S_YYEMPTY; + } + +#if YY_CPLUSPLUS < 201103L + parser::stack_symbol_type& + parser::stack_symbol_type::operator= (const stack_symbol_type& that) + { + state = that.state; + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.copy< int > (that.value); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.copy< std::string > (that.value); + break; + + case symbol_kind::S_index: // index + value.copy< std::tuple > (that.value); + break; + + case symbol_kind::S_indices_list: // indices_list + value.copy< std::vector> > (that.value); + break; + + default: + break; + } + + location = that.location; + return *this; + } + + parser::stack_symbol_type& + parser::stack_symbol_type::operator= (stack_symbol_type& that) + { + state = that.state; + switch (that.kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.move< int > (that.value); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (that.value); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (that.value); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (that.value); + break; + + default: + break; + } + + location = that.location; + // that is emptied. + that.state = empty_state; + return *this; + } +#endif + + template + void + parser::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const + { + if (yymsg) + YY_SYMBOL_PRINT (yymsg, yysym); + } + +#if YYDEBUG + template + void + parser::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const + { + std::ostream& yyoutput = yyo; + YY_USE (yyoutput); + if (yysym.empty ()) + yyo << "empty symbol"; + else + { + symbol_kind_type yykind = yysym.kind (); + yyo << (yykind < YYNTOKENS ? "token" : "nterm") + << ' ' << yysym.name () << " (" + << yysym.location << ": "; + YY_USE (yykind); + yyo << ')'; + } + } +#endif + + void + parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) + { + if (m) + YY_SYMBOL_PRINT (m, sym); + yystack_.push (YY_MOVE (sym)); + } + + void + parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) + { +#if 201103L <= YY_CPLUSPLUS + yypush_ (m, stack_symbol_type (s, std::move (sym))); +#else + stack_symbol_type ss (s, sym); + yypush_ (m, ss); +#endif + } + + void + parser::yypop_ (int n) YY_NOEXCEPT + { + yystack_.pop (n); + } + +#if YYDEBUG + std::ostream& + parser::debug_stream () const + { + return *yycdebug_; + } + + void + parser::set_debug_stream (std::ostream& o) + { + yycdebug_ = &o; + } + + + parser::debug_level_type + parser::debug_level () const + { + return yydebug_; + } + + void + parser::set_debug_level (debug_level_type l) + { + yydebug_ = l; + } +#endif // YYDEBUG + + parser::state_type + parser::yy_lr_goto_state_ (state_type yystate, int yysym) + { + int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; + if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) + return yytable_[yyr]; + else + return yydefgoto_[yysym - YYNTOKENS]; + } + + bool + parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yypact_ninf_; + } + + bool + parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT + { + return yyvalue == yytable_ninf_; + } + + int + parser::operator() () + { + return parse (); + } + + int + parser::parse () + { + int yyn; + /// Length of the RHS of the rule being reduced. + int yylen = 0; + + // Error handling. + int yynerrs_ = 0; + int yyerrstatus_ = 0; + + /// The lookahead symbol. + symbol_type yyla; + + /// The locations where the error started and ended. + stack_symbol_type yyerror_range[3]; + + /// The return value of parse (). + int yyresult; + + // Discard the LAC context in case there still is one left from a + // previous invocation. + yy_lac_discard_ ("init"); + +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + YYCDEBUG << "Starting parse\n"; + + + /* Initialize the stack. The initial state will be set in + yynewstate, since the latter expects the semantical and the + location values to have been already stored, initialize these + stacks with a primary value. */ + yystack_.clear (); + yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); + + /*-----------------------------------------------. + | yynewstate -- push a new symbol on the stack. | + `-----------------------------------------------*/ + yynewstate: + YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; + YY_STACK_PRINT (); + + // Accept? + if (yystack_[0].state == yyfinal_) + YYACCEPT; + + goto yybackup; + + + /*-----------. + | yybackup. | + `-----------*/ + yybackup: + // Try to take a decision without lookahead. + yyn = yypact_[+yystack_[0].state]; + if (yy_pact_value_is_default_ (yyn)) + goto yydefault; + + // Read a lookahead token. + if (yyla.empty ()) + { + YYCDEBUG << "Reading a token\n"; +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + symbol_type yylookahead (yylex (drv)); + yyla.move (yylookahead); + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + goto yyerrlab1; + } +#endif // YY_EXCEPTIONS + } + YY_SYMBOL_PRINT ("Next token is", yyla); + + if (yyla.kind () == symbol_kind::S_YYerror) + { + // The scanner already issued an error message, process directly + // to error recovery. But do not keep the error token as + // lookahead, it is too special and may lead us to an endless + // loop in error recovery. */ + yyla.kind_ = symbol_kind::S_YYUNDEF; + goto yyerrlab1; + } + + /* If the proper action on seeing token YYLA.TYPE is to reduce or + to detect an error, take that action. */ + yyn += yyla.kind (); + if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) + { + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab; + goto yydefault; + } + + // Reduce or error. + yyn = yytable_[yyn]; + if (yyn <= 0) + { + if (yy_table_value_is_error_ (yyn)) + goto yyerrlab; + if (!yy_lac_establish_ (yyla.kind ())) + goto yyerrlab; + + yyn = -yyn; + goto yyreduce; + } + + // Count tokens shifted since error; after three, turn off error status. + if (yyerrstatus_) + --yyerrstatus_; + + // Shift the lookahead token. + yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla)); + yy_lac_discard_ ("shift"); + goto yynewstate; + + + /*-----------------------------------------------------------. + | yydefault -- do the default action for the current state. | + `-----------------------------------------------------------*/ + yydefault: + yyn = yydefact_[+yystack_[0].state]; + if (yyn == 0) + goto yyerrlab; + goto yyreduce; + + + /*-----------------------------. + | yyreduce -- do a reduction. | + `-----------------------------*/ + yyreduce: + yylen = yyr2_[yyn]; + { + stack_symbol_type yylhs; + yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]); + /* Variants are always initialized to an empty instance of the + correct type. The default '$$ = $1' action is NOT applied + when using variants. */ + switch (yyr1_[yyn]) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + yylhs.value.emplace< int > (); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + yylhs.value.emplace< std::string > (); + break; + + case symbol_kind::S_index: // index + yylhs.value.emplace< std::tuple > (); + break; + + case symbol_kind::S_indices_list: // indices_list + yylhs.value.emplace< std::vector> > (); + break; + + default: + break; + } + + + // Default location. + { + stack_type::slice range (yystack_, yylen); + YYLLOC_DEFAULT (yylhs.location, range, yylen); + yyerror_range[1].location = yylhs.location; + } + + // Perform the reduction. + YY_REDUCE_PRINT (yyn); +#if YY_EXCEPTIONS + try +#endif // YY_EXCEPTIONS + { + switch (yyn) + { + case 2: // lines: assignment "\n" lines +#line 62 "parser.y" + {} +#line 644 "parser.cpp" + break; + + case 3: // lines: exp +#line 63 "parser.y" + {} +#line 650 "parser.cpp" + break; + + case 4: // assignment: "identifier" "=" VARNAME +#line 67 "parser.y" + { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } +#line 656 "parser.cpp" + break; + + case 5: // assignment: "identifier" "=" "identifier" +#line 68 "parser.y" + { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } +#line 662 "parser.cpp" + break; + + case 6: // assignment: "identifier" "=" VARNAME "[" indices_list "]" +#line 69 "parser.y" + { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 668 "parser.cpp" + break; + + case 7: // assignment: "identifier" "=" "identifier" "[" indices_list "]" +#line 70 "parser.y" + { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 674 "parser.cpp" + break; + + case 8: // exp: "number" +#line 74 "parser.y" + { } +#line 680 "parser.cpp" + break; + + case 9: // exp: exp OPERATOR exp +#line 75 "parser.y" + { drv.createNode(yystack_[1].value.as < std::string > (), 2); } +#line 686 "parser.cpp" + break; + + case 10: // exp: "(" exp ")" +#line 76 "parser.y" + { } +#line 692 "parser.cpp" + break; + + case 11: // exp: "identifier" "(" list ")" +#line 77 "parser.y" + { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } +#line 698 "parser.cpp" + break; + + case 12: // exp: "identifier" "[" indices_list "]" +#line 78 "parser.y" + { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } +#line 704 "parser.cpp" + break; + + case 13: // exp: "identifier" +#line 79 "parser.y" + { drv.createNode(yystack_[0].value.as < std::string > ()); } +#line 710 "parser.cpp" + break; + + case 14: // indices_list: %empty +#line 84 "parser.y" + { yylhs.value.as < std::vector> > () = {}; } +#line 716 "parser.cpp" + break; + + case 15: // indices_list: indices_list "," index +#line 85 "parser.y" + { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } +#line 722 "parser.cpp" + break; + + case 16: // indices_list: index +#line 86 "parser.y" + { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } +#line 728 "parser.cpp" + break; + + case 17: // index: %empty +#line 90 "parser.y" + { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } +#line 734 "parser.cpp" + break; + + case 18: // index: "number" ":" "number" ":" "number" +#line 91 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } +#line 740 "parser.cpp" + break; + + case 19: // index: ":" "number" ":" "number" +#line 92 "parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } +#line 746 "parser.cpp" + break; + + case 20: // index: "number" ":" ":" "number" +#line 93 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } +#line 752 "parser.cpp" + break; + + case 21: // index: "number" ":" "number" ":" +#line 94 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } +#line 758 "parser.cpp" + break; + + case 22: // index: "number" ":" "number" +#line 95 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } +#line 764 "parser.cpp" + break; + + case 23: // index: ":" ":" "number" +#line 96 "parser.y" + { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } +#line 770 "parser.cpp" + break; + + case 24: // index: ":" "number" ":" +#line 97 "parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } +#line 776 "parser.cpp" + break; + + case 25: // index: ":" "number" +#line 98 "parser.y" + { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } +#line 782 "parser.cpp" + break; + + case 26: // index: "number" ":" ":" +#line 99 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } +#line 788 "parser.cpp" + break; + + case 27: // index: "number" ":" +#line 100 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } +#line 794 "parser.cpp" + break; + + case 28: // index: "number" +#line 101 "parser.y" + { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } +#line 800 "parser.cpp" + break; + + case 29: // list: %empty +#line 105 "parser.y" + { yylhs.value.as < int > () = 0; } +#line 806 "parser.cpp" + break; + + case 30: // list: exp "," list +#line 106 "parser.y" + { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } +#line 812 "parser.cpp" + break; + + case 31: // list: exp +#line 107 "parser.y" + { yylhs.value.as < int > () = 1; } +#line 818 "parser.cpp" + break; + + +#line 822 "parser.cpp" + + default: + break; + } + } +#if YY_EXCEPTIONS + catch (const syntax_error& yyexc) + { + YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; + error (yyexc); + YYERROR; + } +#endif // YY_EXCEPTIONS + YY_SYMBOL_PRINT ("-> $$ =", yylhs); + yypop_ (yylen); + yylen = 0; + + // Shift the result of the reduction. + yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); + } + goto yynewstate; + + + /*--------------------------------------. + | yyerrlab -- here on detecting error. | + `--------------------------------------*/ + yyerrlab: + // If not already recovering from an error, report this error. + if (!yyerrstatus_) + { + ++yynerrs_; + context yyctx (*this, yyla); + std::string msg = yysyntax_error_ (yyctx); + error (yyla.location, YY_MOVE (msg)); + } + + + yyerror_range[1].location = yyla.location; + if (yyerrstatus_ == 3) + { + /* If just tried and failed to reuse lookahead token after an + error, discard it. */ + + // Return failure if at end of input. + if (yyla.kind () == symbol_kind::S_YYEOF) + YYABORT; + else if (!yyla.empty ()) + { + yy_destroy_ ("Error: discarding", yyla); + yyla.clear (); + } + } + + // Else will try to reuse lookahead token after shifting the error token. + goto yyerrlab1; + + + /*---------------------------------------------------. + | yyerrorlab -- error raised explicitly by YYERROR. | + `---------------------------------------------------*/ + yyerrorlab: + /* Pacify compilers when the user code never invokes YYERROR and + the label yyerrorlab therefore never appears in user code. */ + if (false) + YYERROR; + + /* Do not reclaim the symbols of the rule whose action triggered + this YYERROR. */ + yypop_ (yylen); + yylen = 0; + YY_STACK_PRINT (); + goto yyerrlab1; + + + /*-------------------------------------------------------------. + | yyerrlab1 -- common code for both syntax error and YYERROR. | + `-------------------------------------------------------------*/ + yyerrlab1: + yyerrstatus_ = 3; // Each real token shifted decrements this. + // Pop stack until we find a state that shifts the error token. + for (;;) + { + yyn = yypact_[+yystack_[0].state]; + if (!yy_pact_value_is_default_ (yyn)) + { + yyn += symbol_kind::S_YYerror; + if (0 <= yyn && yyn <= yylast_ + && yycheck_[yyn] == symbol_kind::S_YYerror) + { + yyn = yytable_[yyn]; + if (0 < yyn) + break; + } + } + + // Pop the current state because it cannot handle the error token. + if (yystack_.size () == 1) + YYABORT; + + yyerror_range[1].location = yystack_[0].location; + yy_destroy_ ("Error: popping", yystack_[0]); + yypop_ (); + YY_STACK_PRINT (); + } + { + stack_symbol_type error_token; + + yyerror_range[2].location = yyla.location; + YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); + + // Shift the error token. + yy_lac_discard_ ("error recovery"); + error_token.state = state_type (yyn); + yypush_ ("Shifting", YY_MOVE (error_token)); + } + goto yynewstate; + + + /*-------------------------------------. + | yyacceptlab -- YYACCEPT comes here. | + `-------------------------------------*/ + yyacceptlab: + yyresult = 0; + goto yyreturn; + + + /*-----------------------------------. + | yyabortlab -- YYABORT comes here. | + `-----------------------------------*/ + yyabortlab: + yyresult = 1; + goto yyreturn; + + + /*-----------------------------------------------------. + | yyreturn -- parsing is finished, return the result. | + `-----------------------------------------------------*/ + yyreturn: + if (!yyla.empty ()) + yy_destroy_ ("Cleanup: discarding lookahead", yyla); + + /* Do not reclaim the symbols of the rule whose action triggered + this YYABORT or YYACCEPT. */ + yypop_ (yylen); + YY_STACK_PRINT (); + while (1 < yystack_.size ()) + { + yy_destroy_ ("Cleanup: popping", yystack_[0]); + yypop_ (); + } + + return yyresult; + } +#if YY_EXCEPTIONS + catch (...) + { + YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; + // Do not try to display the values of the reclaimed symbols, + // as their printers might throw an exception. + if (!yyla.empty ()) + yy_destroy_ (YY_NULLPTR, yyla); + + while (1 < yystack_.size ()) + { + yy_destroy_ (YY_NULLPTR, yystack_[0]); + yypop_ (); + } + throw; + } +#endif // YY_EXCEPTIONS + } + + void + parser::error (const syntax_error& yyexc) + { + error (yyexc.location, yyexc.what ()); + } + + const char * + parser::symbol_name (symbol_kind_type yysymbol) + { + static const char *const yy_sname[] = + { + "end of file", "error", "invalid token", "=", ",", ":", "(", ")", "[", + "]", "\n", "OPERATOR", "identifier", "VARNAME", "number", "$accept", + "lines", "assignment", "exp", "indices_list", "index", "list", YY_NULLPTR + }; + return yy_sname[yysymbol]; + } + + + + // parser::context. + parser::context::context (const parser& yyparser, const symbol_type& yyla) + : yyparser_ (yyparser) + , yyla_ (yyla) + {} + + int + parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const + { + // Actual number of expected tokens + int yycount = 0; + +#if YYDEBUG + // Execute LAC once. We don't care if it is successful, we + // only do it for the sake of debugging output. + if (!yyparser_.yy_lac_established_) + yyparser_.yy_lac_check_ (yyla_.kind ()); +#endif + + for (int yyx = 0; yyx < YYNTOKENS; ++yyx) + { + symbol_kind_type yysym = YY_CAST (symbol_kind_type, yyx); + if (yysym != symbol_kind::S_YYerror + && yysym != symbol_kind::S_YYUNDEF + && yyparser_.yy_lac_check_ (yysym)) + { + if (!yyarg) + ++yycount; + else if (yycount == yyargn) + return 0; + else + yyarg[yycount++] = yysym; + } + } + if (yyarg && yycount == 0 && 0 < yyargn) + yyarg[0] = symbol_kind::S_YYEMPTY; + return yycount; + } + + + + + bool + parser::yy_lac_check_ (symbol_kind_type yytoken) const + { + // Logically, the yylac_stack's lifetime is confined to this function. + // Clear it, to get rid of potential left-overs from previous call. + yylac_stack_.clear (); + // Reduce until we encounter a shift and thereby accept the token. +#if YYDEBUG + YYCDEBUG << "LAC: checking lookahead " << symbol_name (yytoken) << ':'; +#endif + std::ptrdiff_t lac_top = 0; + while (true) + { + state_type top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + int yyrule = yypact_[+top_state]; + if (yy_pact_value_is_default_ (yyrule) + || (yyrule += yytoken) < 0 || yylast_ < yyrule + || yycheck_[yyrule] != yytoken) + { + // Use the default action. + yyrule = yydefact_[+top_state]; + if (yyrule == 0) + { + YYCDEBUG << " Err\n"; + return false; + } + } + else + { + // Use the action from yytable. + yyrule = yytable_[yyrule]; + if (yy_table_value_is_error_ (yyrule)) + { + YYCDEBUG << " Err\n"; + return false; + } + if (0 < yyrule) + { + YYCDEBUG << " S" << yyrule << '\n'; + return true; + } + yyrule = -yyrule; + } + // By now we know we have to simulate a reduce. + YYCDEBUG << " R" << yyrule - 1; + // Pop the corresponding number of values from the stack. + { + std::ptrdiff_t yylen = yyr2_[yyrule]; + // First pop from the LAC stack as many tokens as possible. + std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); + if (yylen < lac_size) + { + yylac_stack_.resize (std::size_t (lac_size - yylen)); + yylen = 0; + } + else if (lac_size) + { + yylac_stack_.clear (); + yylen -= lac_size; + } + // Only afterwards look at the main stack. + // We simulate popping elements by incrementing lac_top. + lac_top += yylen; + } + // Keep top_state in sync with the updated stack. + top_state = (yylac_stack_.empty () + ? yystack_[lac_top].state + : yylac_stack_.back ()); + // Push the resulting state of the reduction. + state_type state = yy_lr_goto_state_ (top_state, yyr1_[yyrule]); + YYCDEBUG << " G" << int (state); + yylac_stack_.push_back (state); + } + } + + // Establish the initial context if no initial context currently exists. + bool + parser::yy_lac_establish_ (symbol_kind_type yytoken) + { + /* Establish the initial context for the current lookahead if no initial + context is currently established. + + We define a context as a snapshot of the parser stacks. We define + the initial context for a lookahead as the context in which the + parser initially examines that lookahead in order to select a + syntactic action. Thus, if the lookahead eventually proves + syntactically unacceptable (possibly in a later context reached via a + series of reductions), the initial context can be used to determine + the exact set of tokens that would be syntactically acceptable in the + lookahead's place. Moreover, it is the context after which any + further semantic actions would be erroneous because they would be + determined by a syntactically unacceptable token. + + yy_lac_establish_ should be invoked when a reduction is about to be + performed in an inconsistent state (which, for the purposes of LAC, + includes consistent states that don't know they're consistent because + their default reductions have been disabled). + + For parse.lac=full, the implementation of yy_lac_establish_ is as + follows. If no initial context is currently established for the + current lookahead, then check if that lookahead can eventually be + shifted if syntactic actions continue from the current context. */ + if (yy_lac_established_) + return true; + else + { +#if YYDEBUG + YYCDEBUG << "LAC: initial context established for " + << symbol_name (yytoken) << '\n'; +#endif + yy_lac_established_ = true; + return yy_lac_check_ (yytoken); + } + } + + // Discard any previous initial lookahead context. + void + parser::yy_lac_discard_ (const char* event) + { + /* Discard any previous initial lookahead context because of Event, + which may be a lookahead change or an invalidation of the currently + established initial context for the current lookahead. + + The most common example of a lookahead change is a shift. An example + of both cases is syntax error recovery. That is, a syntax error + occurs when the lookahead is syntactically erroneous for the + currently established initial context, so error recovery manipulates + the parser stacks to try to find a new initial context in which the + current lookahead is syntactically acceptable. If it fails to find + such a context, it discards the lookahead. */ + if (yy_lac_established_) + { + YYCDEBUG << "LAC: initial context discarded due to " + << event << '\n'; + yy_lac_established_ = false; + } + } + + + int + parser::yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const + { + /* There are many possibilities here to consider: + - If this state is a consistent state with a default action, then + the only way this function was invoked is if the default action + is an error action. In that case, don't check for expected + tokens because there are none. + - The only way there can be no lookahead present (in yyla) is + if this state is a consistent state with a default action. + Thus, detecting the absence of a lookahead is sufficient to + determine that there is no unexpected or expected token to + report. In that case, just report a simple "syntax error". + - Don't assume there isn't a lookahead just because this state is + a consistent state with a default action. There might have + been a previous inconsistent state, consistent state with a + non-default action, or user semantic action that manipulated + yyla. (However, yyla is currently not documented for users.) + In the first two cases, it might appear that the current syntax + error should have been detected in the previous state when + yy_lac_check was invoked. However, at that time, there might + have been a different syntax error that discarded a different + initial context during error recovery, leaving behind the + current lookahead. + */ + + if (!yyctx.lookahead ().empty ()) + { + if (yyarg) + yyarg[0] = yyctx.token (); + int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); + return yyn + 1; + } + return 0; + } + + // Generate an error message. + std::string + parser::yysyntax_error_ (const context& yyctx) const + { + // Its maximum. + enum { YYARGS_MAX = 5 }; + // Arguments of yyformat. + symbol_kind_type yyarg[YYARGS_MAX]; + int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); + + char const* yyformat = YY_NULLPTR; + switch (yycount) + { +#define YYCASE_(N, S) \ + case N: \ + yyformat = S; \ + break + default: // Avoid compiler warnings. + YYCASE_ (0, YY_("syntax error")); + YYCASE_ (1, YY_("syntax error, unexpected %s")); + YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); + YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); + YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); + YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); +#undef YYCASE_ + } + + std::string yyres; + // Argument number. + std::ptrdiff_t yyi = 0; + for (char const* yyp = yyformat; *yyp; ++yyp) + if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) + { + yyres += symbol_name (yyarg[yyi++]); + ++yyp; + } + else + yyres += *yyp; + return yyres; + } + + + const signed char parser::yypact_ninf_ = -21; + + const signed char parser::yytable_ninf_ = -1; + + const signed char + parser::yypact_[] = + { + 2, 9, 22, -21, 19, 10, 15, 32, 11, -8, + 9, -4, -21, 2, 9, -21, 31, 33, 13, 26, + -3, 30, 25, -21, -21, -21, -4, -4, 9, -21, + 29, 37, -2, -4, -21, 27, 28, -21, -21, 34, + 35, 39, -21, -21, -21, -21, -21, 36, -21 + }; + + const signed char + parser::yydefact_[] = + { + 0, 0, 13, 8, 0, 0, 3, 13, 0, 0, + 29, 14, 1, 0, 0, 10, 5, 4, 31, 0, + 0, 28, 0, 16, 2, 9, 14, 14, 29, 11, + 0, 25, 27, 17, 12, 0, 0, 30, 23, 24, + 26, 22, 15, 7, 6, 19, 20, 21, 18 + }; + + const signed char + parser::yypgoto_[] = + { + -21, 38, -21, -1, -20, 12, 18 + }; + + const signed char + parser::yydefgoto_[] = + { + 0, 4, 5, 6, 22, 23, 19 + }; + + const signed char + parser::yytable_[] = + { + 8, 20, 30, 40, 16, 17, 35, 36, 1, 18, + 21, 31, 41, 25, 2, 1, 3, 28, 15, 12, + 13, 7, 14, 3, 14, 9, 14, 18, 10, 33, + 11, 33, 33, 29, 34, 32, 43, 44, 10, 26, + 11, 27, 39, 38, 47, 42, 37, 0, 45, 46, + 48, 24 + }; + + const signed char + parser::yycheck_[] = + { + 1, 5, 5, 5, 12, 13, 26, 27, 6, 10, + 14, 14, 14, 14, 12, 6, 14, 4, 7, 0, + 10, 12, 11, 14, 11, 3, 11, 28, 6, 4, + 8, 4, 4, 7, 9, 5, 9, 9, 6, 8, + 8, 8, 5, 14, 5, 33, 28, -1, 14, 14, + 14, 13 + }; + + const signed char + parser::yystos_[] = + { + 0, 6, 12, 14, 16, 17, 18, 12, 18, 3, + 6, 8, 0, 10, 11, 7, 12, 13, 18, 21, + 5, 14, 19, 20, 16, 18, 8, 8, 4, 7, + 5, 14, 5, 4, 9, 19, 19, 21, 14, 5, + 5, 14, 20, 9, 9, 14, 14, 5, 14 + }; + + const signed char + parser::yyr1_[] = + { + 0, 15, 16, 16, 17, 17, 17, 17, 18, 18, + 18, 18, 18, 18, 19, 19, 19, 20, 20, 20, + 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, + 21, 21 + }; + + const signed char + parser::yyr2_[] = + { + 0, 2, 3, 1, 3, 3, 6, 6, 1, 3, + 3, 4, 4, 1, 0, 3, 1, 0, 5, 4, + 4, 4, 3, 3, 3, 2, 3, 2, 1, 0, + 3, 1 + }; + + + + +#if YYDEBUG + const signed char + parser::yyrline_[] = + { + 0, 62, 62, 63, 67, 68, 69, 70, 74, 75, + 76, 77, 78, 79, 84, 85, 86, 90, 91, 92, + 93, 94, 95, 96, 97, 98, 99, 100, 101, 105, + 106, 107 + }; + + void + parser::yy_stack_print_ () const + { + *yycdebug_ << "Stack now"; + for (stack_type::const_iterator + i = yystack_.begin (), + i_end = yystack_.end (); + i != i_end; ++i) + *yycdebug_ << ' ' << int (i->state); + *yycdebug_ << '\n'; + } + + void + parser::yy_reduce_print_ (int yyrule) const + { + int yylno = yyrline_[yyrule]; + int yynrhs = yyr2_[yyrule]; + // Print the symbols being reduced, and their result. + *yycdebug_ << "Reducing stack by rule " << yyrule - 1 + << " (line " << yylno << "):\n"; + // The symbols being reduced. + for (int yyi = 0; yyi < yynrhs; yyi++) + YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", + yystack_[(yynrhs) - (yyi + 1)]); + } +#endif // YYDEBUG + + +#line 6 "parser.y" +} } // adios2::detail +#line 1406 "parser.cpp" + +#line 108 "parser.y" + + +void +adios2::detail::parser::error (const location_type& l, const std::string& m) +{ + std::cerr << l << ": " << m << '\n'; +} diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h new file mode 100644 index 0000000000..51884c287a --- /dev/null +++ b/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h @@ -0,0 +1,1626 @@ +// A Bison parser, made by GNU Bison 3.8.2. + +// Skeleton interface for Bison LALR(1) parsers in C++ + +// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +// As a special exception, you may create a larger work that contains +// part or all of the Bison parser skeleton and distribute that work +// under terms of your choice, so long as that work isn't itself a +// parser generator using the skeleton or a modified version thereof +// as a parser skeleton. Alternatively, if you modify or redistribute +// the parser skeleton itself, you may (at your option) remove this +// special exception, which will cause the skeleton and the resulting +// Bison output files to be licensed under the GNU General Public +// License without this special exception. + +// This special exception was added by the Free Software Foundation in +// version 2.2 of Bison. + + +/** + ** \file parser.h + ** Define the adios2::detail::parser class. + */ + +// C++ LALR(1) parser skeleton written by Akim Demaille. + +// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, +// especially those whose name start with YY_ or yy_. They are +// private implementation details that can be changed or removed. + +#ifndef YY_YY_PARSER_H_INCLUDED +# define YY_YY_PARSER_H_INCLUDED +// "%code requires" blocks. +#line 11 "parser.y" + + #include + #include + #include + namespace adios2 + { + namespace detail + { + class ASTDriver; + } + } + +#line 62 "parser.h" + +# include +# include // std::abort +# include +# include +# include +# include + +#if defined __cplusplus +# define YY_CPLUSPLUS __cplusplus +#else +# define YY_CPLUSPLUS 199711L +#endif + +// Support move semantics when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_MOVE std::move +# define YY_MOVE_OR_COPY move +# define YY_MOVE_REF(Type) Type&& +# define YY_RVREF(Type) Type&& +# define YY_COPY(Type) Type +#else +# define YY_MOVE +# define YY_MOVE_OR_COPY copy +# define YY_MOVE_REF(Type) Type& +# define YY_RVREF(Type) const Type& +# define YY_COPY(Type) const Type& +#endif + +// Support noexcept when possible. +#if 201103L <= YY_CPLUSPLUS +# define YY_NOEXCEPT noexcept +# define YY_NOTHROW +#else +# define YY_NOEXCEPT +# define YY_NOTHROW throw () +#endif + +// Support constexpr when possible. +#if 201703 <= YY_CPLUSPLUS +# define YY_CONSTEXPR constexpr +#else +# define YY_CONSTEXPR +#endif +# include "location.hh" +#include +#ifndef YY_ASSERT +# include +# define YY_ASSERT assert +#endif + + +#ifndef YY_ATTRIBUTE_PURE +# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) +# else +# define YY_ATTRIBUTE_PURE +# endif +#endif + +#ifndef YY_ATTRIBUTE_UNUSED +# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) +# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) +# else +# define YY_ATTRIBUTE_UNUSED +# endif +#endif + +/* Suppress unused-variable warnings by "using" E. */ +#if ! defined lint || defined __GNUC__ +# define YY_USE(E) ((void) (E)) +#else +# define YY_USE(E) /* empty */ +#endif + +/* Suppress an incorrect diagnostic about yylval being uninitialized. */ +#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ +# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") +# else +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ + _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") +# endif +# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ + _Pragma ("GCC diagnostic pop") +#else +# define YY_INITIAL_VALUE(Value) Value +#endif +#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN +# define YY_IGNORE_MAYBE_UNINITIALIZED_END +#endif +#ifndef YY_INITIAL_VALUE +# define YY_INITIAL_VALUE(Value) /* Nothing. */ +#endif + +#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ +# define YY_IGNORE_USELESS_CAST_BEGIN \ + _Pragma ("GCC diagnostic push") \ + _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") +# define YY_IGNORE_USELESS_CAST_END \ + _Pragma ("GCC diagnostic pop") +#endif +#ifndef YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_BEGIN +# define YY_IGNORE_USELESS_CAST_END +#endif + +# ifndef YY_CAST +# ifdef __cplusplus +# define YY_CAST(Type, Val) static_cast (Val) +# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) +# else +# define YY_CAST(Type, Val) ((Type) (Val)) +# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) +# endif +# endif +# ifndef YY_NULLPTR +# if defined __cplusplus +# if 201103L <= __cplusplus +# define YY_NULLPTR nullptr +# else +# define YY_NULLPTR 0 +# endif +# else +# define YY_NULLPTR ((void*)0) +# endif +# endif + +/* Debug traces. */ +#ifndef YYDEBUG +# define YYDEBUG 1 +#endif + +#line 6 "parser.y" +namespace adios2 { namespace detail { +#line 203 "parser.h" + + + + + /// A Bison parser. + class parser + { + public: +#ifdef YYSTYPE +# ifdef __GNUC__ +# pragma GCC message "bison: do not #define YYSTYPE in C++, use %define api.value.type" +# endif + typedef YYSTYPE value_type; +#else + /// A buffer to store and retrieve objects. + /// + /// Sort of a variant, but does not keep track of the nature + /// of the stored data, since that knowledge is available + /// via the current parser state. + class value_type + { + public: + /// Type of *this. + typedef value_type self_type; + + /// Empty construction. + value_type () YY_NOEXCEPT + : yyraw_ () + , yytypeid_ (YY_NULLPTR) + {} + + /// Construct and fill. + template + value_type (YY_RVREF (T) t) + : yytypeid_ (&typeid (T)) + { + YY_ASSERT (sizeof (T) <= size); + new (yyas_ ()) T (YY_MOVE (t)); + } + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + value_type (const self_type&) = delete; + /// Non copyable. + self_type& operator= (const self_type&) = delete; +#endif + + /// Destruction, allowed only if empty. + ~value_type () YY_NOEXCEPT + { + YY_ASSERT (!yytypeid_); + } + +# if 201103L <= YY_CPLUSPLUS + /// Instantiate a \a T in here from \a t. + template + T& + emplace (U&&... u) + { + YY_ASSERT (!yytypeid_); + YY_ASSERT (sizeof (T) <= size); + yytypeid_ = & typeid (T); + return *new (yyas_ ()) T (std::forward (u)...); + } +# else + /// Instantiate an empty \a T in here. + template + T& + emplace () + { + YY_ASSERT (!yytypeid_); + YY_ASSERT (sizeof (T) <= size); + yytypeid_ = & typeid (T); + return *new (yyas_ ()) T (); + } + + /// Instantiate a \a T in here from \a t. + template + T& + emplace (const T& t) + { + YY_ASSERT (!yytypeid_); + YY_ASSERT (sizeof (T) <= size); + yytypeid_ = & typeid (T); + return *new (yyas_ ()) T (t); + } +# endif + + /// Instantiate an empty \a T in here. + /// Obsolete, use emplace. + template + T& + build () + { + return emplace (); + } + + /// Instantiate a \a T in here from \a t. + /// Obsolete, use emplace. + template + T& + build (const T& t) + { + return emplace (t); + } + + /// Accessor to a built \a T. + template + T& + as () YY_NOEXCEPT + { + YY_ASSERT (yytypeid_); + YY_ASSERT (*yytypeid_ == typeid (T)); + YY_ASSERT (sizeof (T) <= size); + return *yyas_ (); + } + + /// Const accessor to a built \a T (for %printer). + template + const T& + as () const YY_NOEXCEPT + { + YY_ASSERT (yytypeid_); + YY_ASSERT (*yytypeid_ == typeid (T)); + YY_ASSERT (sizeof (T) <= size); + return *yyas_ (); + } + + /// Swap the content with \a that, of same type. + /// + /// Both variants must be built beforehand, because swapping the actual + /// data requires reading it (with as()), and this is not possible on + /// unconstructed variants: it would require some dynamic testing, which + /// should not be the variant's responsibility. + /// Swapping between built and (possibly) non-built is done with + /// self_type::move (). + template + void + swap (self_type& that) YY_NOEXCEPT + { + YY_ASSERT (yytypeid_); + YY_ASSERT (*yytypeid_ == *that.yytypeid_); + std::swap (as (), that.as ()); + } + + /// Move the content of \a that to this. + /// + /// Destroys \a that. + template + void + move (self_type& that) + { +# if 201103L <= YY_CPLUSPLUS + emplace (std::move (that.as ())); +# else + emplace (); + swap (that); +# endif + that.destroy (); + } + +# if 201103L <= YY_CPLUSPLUS + /// Move the content of \a that to this. + template + void + move (self_type&& that) + { + emplace (std::move (that.as ())); + that.destroy (); + } +#endif + + /// Copy the content of \a that to this. + template + void + copy (const self_type& that) + { + emplace (that.as ()); + } + + /// Destroy the stored \a T. + template + void + destroy () + { + as ().~T (); + yytypeid_ = YY_NULLPTR; + } + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + value_type (const self_type&); + /// Non copyable. + self_type& operator= (const self_type&); +#endif + + /// Accessor to raw memory as \a T. + template + T* + yyas_ () YY_NOEXCEPT + { + void *yyp = yyraw_; + return static_cast (yyp); + } + + /// Const accessor to raw memory as \a T. + template + const T* + yyas_ () const YY_NOEXCEPT + { + const void *yyp = yyraw_; + return static_cast (yyp); + } + + /// An auxiliary type to compute the largest semantic type. + union union_type + { + // "number" + // list + char dummy1[sizeof (int)]; + + // OPERATOR + // "identifier" + // VARNAME + char dummy2[sizeof (std::string)]; + + // index + char dummy3[sizeof (std::tuple)]; + + // indices_list + char dummy4[sizeof (std::vector>)]; + }; + + /// The size of the largest semantic type. + enum { size = sizeof (union_type) }; + + /// A buffer to store semantic values. + union + { + /// Strongest alignment constraints. + long double yyalign_me_; + /// A buffer large enough to store any of the semantic values. + char yyraw_[size]; + }; + + /// Whether the content is built: if defined, the name of the stored type. + const std::type_info *yytypeid_; + }; + +#endif + /// Backward compatibility (Bison 3.8). + typedef value_type semantic_type; + + /// Symbol locations. + typedef location location_type; + + /// Syntax errors thrown from user actions. + struct syntax_error : std::runtime_error + { + syntax_error (const location_type& l, const std::string& m) + : std::runtime_error (m) + , location (l) + {} + + syntax_error (const syntax_error& s) + : std::runtime_error (s.what ()) + , location (s.location) + {} + + ~syntax_error () YY_NOEXCEPT YY_NOTHROW; + + location_type location; + }; + + /// Token kinds. + struct token + { + enum token_kind_type + { + TOK_YYEMPTY = -2, + TOK_YYEOF = 0, // "end of file" + TOK_YYerror = 1, // error + TOK_YYUNDEF = 2, // "invalid token" + TOK_ASSIGN = 3, // "=" + TOK_COMMA = 4, // "," + TOK_COLON = 5, // ":" + TOK_L_PAREN = 6, // "(" + TOK_R_PAREN = 7, // ")" + TOK_L_BRACE = 8, // "[" + TOK_R_BRACE = 9, // "]" + TOK_ENDL = 10, // "\n" + TOK_OPERATOR = 11, // OPERATOR + TOK_IDENTIFIER = 12, // "identifier" + TOK_VARNAME = 13, // VARNAME + TOK_INT = 14 // "number" + }; + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type yytokentype; + }; + + /// Token kind, as returned by yylex. + typedef token::token_kind_type token_kind_type; + + /// Backward compatibility alias (Bison 3.6). + typedef token_kind_type token_type; + + /// Symbol kinds. + struct symbol_kind + { + enum symbol_kind_type + { + YYNTOKENS = 15, ///< Number of tokens. + S_YYEMPTY = -2, + S_YYEOF = 0, // "end of file" + S_YYerror = 1, // error + S_YYUNDEF = 2, // "invalid token" + S_ASSIGN = 3, // "=" + S_COMMA = 4, // "," + S_COLON = 5, // ":" + S_L_PAREN = 6, // "(" + S_R_PAREN = 7, // ")" + S_L_BRACE = 8, // "[" + S_R_BRACE = 9, // "]" + S_ENDL = 10, // "\n" + S_OPERATOR = 11, // OPERATOR + S_IDENTIFIER = 12, // "identifier" + S_VARNAME = 13, // VARNAME + S_INT = 14, // "number" + S_YYACCEPT = 15, // $accept + S_lines = 16, // lines + S_assignment = 17, // assignment + S_exp = 18, // exp + S_indices_list = 19, // indices_list + S_index = 20, // index + S_list = 21 // list + }; + }; + + /// (Internal) symbol kind. + typedef symbol_kind::symbol_kind_type symbol_kind_type; + + /// The number of tokens. + static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; + + /// A complete symbol. + /// + /// Expects its Base type to provide access to the symbol kind + /// via kind (). + /// + /// Provide access to semantic value and location. + template + struct basic_symbol : Base + { + /// Alias to Base. + typedef Base super_type; + + /// Default constructor. + basic_symbol () YY_NOEXCEPT + : value () + , location () + {} + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + basic_symbol (basic_symbol&& that) + : Base (std::move (that)) + , value () + , location (std::move (that.location)) + { + switch (this->kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.move< int > (std::move (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (std::move (that.value)); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (std::move (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (std::move (that.value)); + break; + + default: + break; + } + + } +#endif + + /// Copy constructor. + basic_symbol (const basic_symbol& that); + + /// Constructors for typed symbols. +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, location_type&& l) + : Base (t) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const location_type& l) + : Base (t) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, int&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const int& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, std::tuple&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const std::tuple& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + +#if 201103L <= YY_CPLUSPLUS + basic_symbol (typename Base::kind_type t, std::vector>&& v, location_type&& l) + : Base (t) + , value (std::move (v)) + , location (std::move (l)) + {} +#else + basic_symbol (typename Base::kind_type t, const std::vector>& v, const location_type& l) + : Base (t) + , value (v) + , location (l) + {} +#endif + + /// Destroy the symbol. + ~basic_symbol () + { + clear (); + } + + + + /// Destroy contents, and record that is empty. + void clear () YY_NOEXCEPT + { + // User destructor. + symbol_kind_type yykind = this->kind (); + basic_symbol& yysym = *this; + (void) yysym; + switch (yykind) + { + default: + break; + } + + // Value type destructor. +switch (yykind) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.template destroy< int > (); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.template destroy< std::string > (); + break; + + case symbol_kind::S_index: // index + value.template destroy< std::tuple > (); + break; + + case symbol_kind::S_indices_list: // indices_list + value.template destroy< std::vector> > (); + break; + + default: + break; + } + + Base::clear (); + } + + /// The user-facing name of this symbol. + const char *name () const YY_NOEXCEPT + { + return parser::symbol_name (this->kind ()); + } + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + + /// Whether empty. + bool empty () const YY_NOEXCEPT; + + /// Destructive move, \a s is emptied into this. + void move (basic_symbol& s); + + /// The semantic value. + value_type value; + + /// The location. + location_type location; + + private: +#if YY_CPLUSPLUS < 201103L + /// Assignment operator. + basic_symbol& operator= (const basic_symbol& that); +#endif + }; + + /// Type access provider for token (enum) based symbols. + struct by_kind + { + /// The symbol kind as needed by the constructor. + typedef token_kind_type kind_type; + + /// Default constructor. + by_kind () YY_NOEXCEPT; + +#if 201103L <= YY_CPLUSPLUS + /// Move constructor. + by_kind (by_kind&& that) YY_NOEXCEPT; +#endif + + /// Copy constructor. + by_kind (const by_kind& that) YY_NOEXCEPT; + + /// Constructor from (external) token numbers. + by_kind (kind_type t) YY_NOEXCEPT; + + + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_kind& that); + + /// The (internal) type number (corresponding to \a type). + /// \a empty when empty. + symbol_kind_type kind () const YY_NOEXCEPT; + + /// Backward compatibility (Bison 3.6). + symbol_kind_type type_get () const YY_NOEXCEPT; + + /// The symbol kind. + /// \a S_YYEMPTY when empty. + symbol_kind_type kind_; + }; + + /// Backward compatibility for a private implementation detail (Bison 3.6). + typedef by_kind by_type; + + /// "External" symbols: returned by the scanner. + struct symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + + /// Empty symbol. + symbol_type () YY_NOEXCEPT {} + + /// Constructor for valueless symbols, and symbols from each type. +#if 201103L <= YY_CPLUSPLUS + symbol_type (int tok, location_type l) + : super_type (token_kind_type (tok), std::move (l)) +#else + symbol_type (int tok, const location_type& l) + : super_type (token_kind_type (tok), l) +#endif + { +#if !defined _MSC_VER || defined __clang__ + YY_ASSERT (tok == token::TOK_YYEOF + || (token::TOK_YYerror <= tok && tok <= token::TOK_ENDL)); +#endif + } +#if 201103L <= YY_CPLUSPLUS + symbol_type (int tok, int v, location_type l) + : super_type (token_kind_type (tok), std::move (v), std::move (l)) +#else + symbol_type (int tok, const int& v, const location_type& l) + : super_type (token_kind_type (tok), v, l) +#endif + { +#if !defined _MSC_VER || defined __clang__ + YY_ASSERT (tok == token::TOK_INT); +#endif + } +#if 201103L <= YY_CPLUSPLUS + symbol_type (int tok, std::string v, location_type l) + : super_type (token_kind_type (tok), std::move (v), std::move (l)) +#else + symbol_type (int tok, const std::string& v, const location_type& l) + : super_type (token_kind_type (tok), v, l) +#endif + { +#if !defined _MSC_VER || defined __clang__ + YY_ASSERT ((token::TOK_OPERATOR <= tok && tok <= token::TOK_VARNAME)); +#endif + } + }; + + /// Build a parser object. + parser (ASTDriver& drv_yyarg); + virtual ~parser (); + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + parser (const parser&) = delete; + /// Non copyable. + parser& operator= (const parser&) = delete; +#endif + + /// Parse. An alias for parse (). + /// \returns 0 iff parsing succeeded. + int operator() (); + + /// Parse. + /// \returns 0 iff parsing succeeded. + virtual int parse (); + +#if YYDEBUG + /// The current debugging stream. + std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; + /// Set the current debugging stream. + void set_debug_stream (std::ostream &); + + /// Type for debugging levels. + typedef int debug_level_type; + /// The current debugging level. + debug_level_type debug_level () const YY_ATTRIBUTE_PURE; + /// Set the current debugging level. + void set_debug_level (debug_level_type l); +#endif + + /// Report a syntax error. + /// \param loc where the syntax error is found. + /// \param msg a description of the syntax error. + virtual void error (const location_type& loc, const std::string& msg); + + /// Report a syntax error. + void error (const syntax_error& err); + + /// The user-facing name of the symbol whose (internal) number is + /// YYSYMBOL. No bounds checking. + static const char *symbol_name (symbol_kind_type yysymbol); + + // Implementation of make_symbol for each token kind. +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_YYEOF (location_type l) + { + return symbol_type (token::TOK_YYEOF, std::move (l)); + } +#else + static + symbol_type + make_YYEOF (const location_type& l) + { + return symbol_type (token::TOK_YYEOF, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_YYerror (location_type l) + { + return symbol_type (token::TOK_YYerror, std::move (l)); + } +#else + static + symbol_type + make_YYerror (const location_type& l) + { + return symbol_type (token::TOK_YYerror, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_YYUNDEF (location_type l) + { + return symbol_type (token::TOK_YYUNDEF, std::move (l)); + } +#else + static + symbol_type + make_YYUNDEF (const location_type& l) + { + return symbol_type (token::TOK_YYUNDEF, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_ASSIGN (location_type l) + { + return symbol_type (token::TOK_ASSIGN, std::move (l)); + } +#else + static + symbol_type + make_ASSIGN (const location_type& l) + { + return symbol_type (token::TOK_ASSIGN, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_COMMA (location_type l) + { + return symbol_type (token::TOK_COMMA, std::move (l)); + } +#else + static + symbol_type + make_COMMA (const location_type& l) + { + return symbol_type (token::TOK_COMMA, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_COLON (location_type l) + { + return symbol_type (token::TOK_COLON, std::move (l)); + } +#else + static + symbol_type + make_COLON (const location_type& l) + { + return symbol_type (token::TOK_COLON, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_L_PAREN (location_type l) + { + return symbol_type (token::TOK_L_PAREN, std::move (l)); + } +#else + static + symbol_type + make_L_PAREN (const location_type& l) + { + return symbol_type (token::TOK_L_PAREN, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_R_PAREN (location_type l) + { + return symbol_type (token::TOK_R_PAREN, std::move (l)); + } +#else + static + symbol_type + make_R_PAREN (const location_type& l) + { + return symbol_type (token::TOK_R_PAREN, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_L_BRACE (location_type l) + { + return symbol_type (token::TOK_L_BRACE, std::move (l)); + } +#else + static + symbol_type + make_L_BRACE (const location_type& l) + { + return symbol_type (token::TOK_L_BRACE, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_R_BRACE (location_type l) + { + return symbol_type (token::TOK_R_BRACE, std::move (l)); + } +#else + static + symbol_type + make_R_BRACE (const location_type& l) + { + return symbol_type (token::TOK_R_BRACE, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_ENDL (location_type l) + { + return symbol_type (token::TOK_ENDL, std::move (l)); + } +#else + static + symbol_type + make_ENDL (const location_type& l) + { + return symbol_type (token::TOK_ENDL, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_OPERATOR (std::string v, location_type l) + { + return symbol_type (token::TOK_OPERATOR, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_OPERATOR (const std::string& v, const location_type& l) + { + return symbol_type (token::TOK_OPERATOR, v, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_IDENTIFIER (std::string v, location_type l) + { + return symbol_type (token::TOK_IDENTIFIER, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_IDENTIFIER (const std::string& v, const location_type& l) + { + return symbol_type (token::TOK_IDENTIFIER, v, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_VARNAME (std::string v, location_type l) + { + return symbol_type (token::TOK_VARNAME, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_VARNAME (const std::string& v, const location_type& l) + { + return symbol_type (token::TOK_VARNAME, v, l); + } +#endif +#if 201103L <= YY_CPLUSPLUS + static + symbol_type + make_INT (int v, location_type l) + { + return symbol_type (token::TOK_INT, std::move (v), std::move (l)); + } +#else + static + symbol_type + make_INT (const int& v, const location_type& l) + { + return symbol_type (token::TOK_INT, v, l); + } +#endif + + + class context + { + public: + context (const parser& yyparser, const symbol_type& yyla); + const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } + symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); } + const location_type& location () const YY_NOEXCEPT { return yyla_.location; } + + /// Put in YYARG at most YYARGN of the expected tokens, and return the + /// number of tokens stored in YYARG. If YYARG is null, return the + /// number of expected tokens (guaranteed to be less than YYNTOKENS). + int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; + + private: + const parser& yyparser_; + const symbol_type& yyla_; + }; + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + parser (const parser&); + /// Non copyable. + parser& operator= (const parser&); +#endif + + /// Check the lookahead yytoken. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_check_ (symbol_kind_type yytoken) const; + /// Establish the initial context if no initial context currently exists. + /// \returns true iff the token will be eventually shifted. + bool yy_lac_establish_ (symbol_kind_type yytoken); + /// Discard any previous initial lookahead context because of event. + /// \param event the event which caused the lookahead to be discarded. + /// Only used for debbuging output. + void yy_lac_discard_ (const char* event); + + /// Stored state numbers (used for stacks). + typedef signed char state_type; + + /// The arguments of the error message. + int yy_syntax_error_arguments_ (const context& yyctx, + symbol_kind_type yyarg[], int yyargn) const; + + /// Generate an error message. + /// \param yyctx the context in which the error occurred. + virtual std::string yysyntax_error_ (const context& yyctx) const; + /// Compute post-reduction state. + /// \param yystate the current state + /// \param yysym the nonterminal to push on the stack + static state_type yy_lr_goto_state_ (state_type yystate, int yysym); + + /// Whether the given \c yypact_ value indicates a defaulted state. + /// \param yyvalue the value to check + static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT; + + /// Whether the given \c yytable_ value indicates a syntax error. + /// \param yyvalue the value to check + static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT; + + static const signed char yypact_ninf_; + static const signed char yytable_ninf_; + + /// Convert a scanner token kind \a t to a symbol kind. + /// In theory \a t should be a token_kind_type, but character literals + /// are valid, yet not members of the token_kind_type enum. + static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; + + + + // Tables. + // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing + // STATE-NUM. + static const signed char yypact_[]; + + // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. + // Performed when YYTABLE does not specify something else to do. Zero + // means the default is an error. + static const signed char yydefact_[]; + + // YYPGOTO[NTERM-NUM]. + static const signed char yypgoto_[]; + + // YYDEFGOTO[NTERM-NUM]. + static const signed char yydefgoto_[]; + + // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If + // positive, shift that token. If negative, reduce the rule whose + // number is the opposite. If YYTABLE_NINF, syntax error. + static const signed char yytable_[]; + + static const signed char yycheck_[]; + + // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of + // state STATE-NUM. + static const signed char yystos_[]; + + // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. + static const signed char yyr1_[]; + + // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. + static const signed char yyr2_[]; + + +#if YYDEBUG + // YYRLINE[YYN] -- Source line where rule number YYN was defined. + static const signed char yyrline_[]; + /// Report on the debug stream that the rule \a r is going to be reduced. + virtual void yy_reduce_print_ (int r) const; + /// Print the state stack on the debug stream. + virtual void yy_stack_print_ () const; + + /// Debugging level. + int yydebug_; + /// Debug stream. + std::ostream* yycdebug_; + + /// \brief Display a symbol kind, value and location. + /// \param yyo The output stream. + /// \param yysym The symbol. + template + void yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const; +#endif + + /// \brief Reclaim the memory associated to a symbol. + /// \param yymsg Why this token is reclaimed. + /// If null, print nothing. + /// \param yysym The symbol. + template + void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; + + private: + /// Type access provider for state based symbols. + struct by_state + { + /// Default constructor. + by_state () YY_NOEXCEPT; + + /// The symbol kind as needed by the constructor. + typedef state_type kind_type; + + /// Constructor. + by_state (kind_type s) YY_NOEXCEPT; + + /// Copy constructor. + by_state (const by_state& that) YY_NOEXCEPT; + + /// Record that this symbol is empty. + void clear () YY_NOEXCEPT; + + /// Steal the symbol kind from \a that. + void move (by_state& that); + + /// The symbol kind (corresponding to \a state). + /// \a symbol_kind::S_YYEMPTY when empty. + symbol_kind_type kind () const YY_NOEXCEPT; + + /// The state number used to denote an empty symbol. + /// We use the initial state, as it does not have a value. + enum { empty_state = 0 }; + + /// The state. + /// \a empty when empty. + state_type state; + }; + + /// "Internal" symbol: element of the stack. + struct stack_symbol_type : basic_symbol + { + /// Superclass. + typedef basic_symbol super_type; + /// Construct an empty symbol. + stack_symbol_type (); + /// Move or copy construction. + stack_symbol_type (YY_RVREF (stack_symbol_type) that); + /// Steal the contents from \a sym to build this. + stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); +#if YY_CPLUSPLUS < 201103L + /// Assignment, needed by push_back by some old implementations. + /// Moves the contents of that. + stack_symbol_type& operator= (stack_symbol_type& that); + + /// Assignment, needed by push_back by other implementations. + /// Needed by some other old implementations. + stack_symbol_type& operator= (const stack_symbol_type& that); +#endif + }; + + /// A stack with random access from its top. + template > + class stack + { + public: + // Hide our reversed order. + typedef typename S::iterator iterator; + typedef typename S::const_iterator const_iterator; + typedef typename S::size_type size_type; + typedef typename std::ptrdiff_t index_type; + + stack (size_type n = 200) YY_NOEXCEPT + : seq_ (n) + {} + +#if 201103L <= YY_CPLUSPLUS + /// Non copyable. + stack (const stack&) = delete; + /// Non copyable. + stack& operator= (const stack&) = delete; +#endif + + /// Random access. + /// + /// Index 0 returns the topmost element. + const T& + operator[] (index_type i) const + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Random access. + /// + /// Index 0 returns the topmost element. + T& + operator[] (index_type i) + { + return seq_[size_type (size () - 1 - i)]; + } + + /// Steal the contents of \a t. + /// + /// Close to move-semantics. + void + push (YY_MOVE_REF (T) t) + { + seq_.push_back (T ()); + operator[] (0).move (t); + } + + /// Pop elements from the stack. + void + pop (std::ptrdiff_t n = 1) YY_NOEXCEPT + { + for (; 0 < n; --n) + seq_.pop_back (); + } + + /// Pop all elements from the stack. + void + clear () YY_NOEXCEPT + { + seq_.clear (); + } + + /// Number of elements on the stack. + index_type + size () const YY_NOEXCEPT + { + return index_type (seq_.size ()); + } + + /// Iterator on top of the stack (going downwards). + const_iterator + begin () const YY_NOEXCEPT + { + return seq_.begin (); + } + + /// Bottom of the stack. + const_iterator + end () const YY_NOEXCEPT + { + return seq_.end (); + } + + /// Present a slice of the top of a stack. + class slice + { + public: + slice (const stack& stack, index_type range) YY_NOEXCEPT + : stack_ (stack) + , range_ (range) + {} + + const T& + operator[] (index_type i) const + { + return stack_[range_ - i]; + } + + private: + const stack& stack_; + index_type range_; + }; + + private: +#if YY_CPLUSPLUS < 201103L + /// Non copyable. + stack (const stack&); + /// Non copyable. + stack& operator= (const stack&); +#endif + /// The wrapped container. + S seq_; + }; + + + /// Stack type. + typedef stack stack_type; + + /// The stack. + stack_type yystack_; + /// The stack for LAC. + /// Logically, the yy_lac_stack's lifetime is confined to the function + /// yy_lac_check_. We just store it as a member of this class to hold + /// on to the memory and to avoid frequent reallocations. + /// Since yy_lac_check_ is const, this member must be mutable. + mutable std::vector yylac_stack_; + /// Whether an initial LAC context was established. + bool yy_lac_established_; + + + /// Push a new state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param sym the symbol + /// \warning the contents of \a s.value is stolen. + void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); + + /// Push a new look ahead token on the state on the stack. + /// \param m a debug message to display + /// if null, no trace is output. + /// \param s the state + /// \param sym the symbol (for its value and location). + /// \warning the contents of \a sym.value is stolen. + void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); + + /// Pop \a n symbols from the stack. + void yypop_ (int n = 1) YY_NOEXCEPT; + + /// Constants. + enum + { + yylast_ = 51, ///< Last index in yytable_. + yynnts_ = 7, ///< Number of nonterminal symbols. + yyfinal_ = 12 ///< Termination state number. + }; + + + // User arguments. + ASTDriver& drv; + + }; + + inline + parser::symbol_kind_type + parser::yytranslate_ (int t) YY_NOEXCEPT + { + return static_cast (t); + } + + // basic_symbol. + template + parser::basic_symbol::basic_symbol (const basic_symbol& that) + : Base (that) + , value () + , location (that.location) + { + switch (this->kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.copy< int > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.copy< std::string > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_index: // index + value.copy< std::tuple > (YY_MOVE (that.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.copy< std::vector> > (YY_MOVE (that.value)); + break; + + default: + break; + } + + } + + + + + template + parser::symbol_kind_type + parser::basic_symbol::type_get () const YY_NOEXCEPT + { + return this->kind (); + } + + + template + bool + parser::basic_symbol::empty () const YY_NOEXCEPT + { + return this->kind () == symbol_kind::S_YYEMPTY; + } + + template + void + parser::basic_symbol::move (basic_symbol& s) + { + super_type::move (s); + switch (this->kind ()) + { + case symbol_kind::S_INT: // "number" + case symbol_kind::S_list: // list + value.move< int > (YY_MOVE (s.value)); + break; + + case symbol_kind::S_OPERATOR: // OPERATOR + case symbol_kind::S_IDENTIFIER: // "identifier" + case symbol_kind::S_VARNAME: // VARNAME + value.move< std::string > (YY_MOVE (s.value)); + break; + + case symbol_kind::S_index: // index + value.move< std::tuple > (YY_MOVE (s.value)); + break; + + case symbol_kind::S_indices_list: // indices_list + value.move< std::vector> > (YY_MOVE (s.value)); + break; + + default: + break; + } + + location = YY_MOVE (s.location); + } + + // by_kind. + inline + parser::by_kind::by_kind () YY_NOEXCEPT + : kind_ (symbol_kind::S_YYEMPTY) + {} + +#if 201103L <= YY_CPLUSPLUS + inline + parser::by_kind::by_kind (by_kind&& that) YY_NOEXCEPT + : kind_ (that.kind_) + { + that.clear (); + } +#endif + + inline + parser::by_kind::by_kind (const by_kind& that) YY_NOEXCEPT + : kind_ (that.kind_) + {} + + inline + parser::by_kind::by_kind (token_kind_type t) YY_NOEXCEPT + : kind_ (yytranslate_ (t)) + {} + + + + inline + void + parser::by_kind::clear () YY_NOEXCEPT + { + kind_ = symbol_kind::S_YYEMPTY; + } + + inline + void + parser::by_kind::move (by_kind& that) + { + kind_ = that.kind_; + that.clear (); + } + + inline + parser::symbol_kind_type + parser::by_kind::kind () const YY_NOEXCEPT + { + return kind_; + } + + + inline + parser::symbol_kind_type + parser::by_kind::type_get () const YY_NOEXCEPT + { + return this->kind (); + } + + +#line 6 "parser.y" +} } // adios2::detail +#line 1622 "parser.h" + + + + +#endif // !YY_YY_PARSER_H_INCLUDED From 7ed2bc09b33184b83dbc4b3047871c5e0acfdf29 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 3 Mar 2024 19:56:13 +0000 Subject: [PATCH 22/46] temporary fix for stdint issues --- .../toolkit/derived/parser/pregen-source/Windows/lexer.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp index 61b3f506af..a8361f032e 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp @@ -17,6 +17,7 @@ /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ +#include #include #include #include From 4c18d3f4a043fe6f9640e06ab28ae31933caa6e5 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Mon, 4 Mar 2024 12:27:54 -0500 Subject: [PATCH 23/46] Fixing CI build warnings: convert size_t to int, clearing an object of non-trivial type --- source/adios2/core/VariableDerived.cpp | 2 +- source/adios2/toolkit/derived/Function.tcc | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/adios2/core/VariableDerived.cpp b/source/adios2/core/VariableDerived.cpp index d06c5601d6..c06a7265d6 100644 --- a/source/adios2/core/VariableDerived.cpp +++ b/source/adios2/core/VariableDerived.cpp @@ -52,7 +52,7 @@ VariableDerived::ApplyExpression(std::map NameToMVI) { Dims start; Dims count; - for (size_t d = 0; d < variable.second.Dims; d++) + for (int d = 0; d < variable.second.Dims; d++) { start.push_back(variable.second.BlocksInfo[i].Start[d]); count.push_back(variable.second.BlocksInfo[i].Count[d]); diff --git a/source/adios2/toolkit/derived/Function.tcc b/source/adios2/toolkit/derived/Function.tcc index 1c47c1665b..b96200aa02 100644 --- a/source/adios2/toolkit/derived/Function.tcc +++ b/source/adios2/toolkit/derived/Function.tcc @@ -22,7 +22,7 @@ T *ApplyOneToOne(std::vector inputData, size_t dataSize, std::cout << "Allocation failed for the derived data" << std::endl; // TODO - throw an exception } - memset(outValues, 0, dataSize * sizeof(T)); + memset((void*)outValues, 0, dataSize * sizeof(T)); for (auto &variable : inputData) { for (size_t i = 0; i < dataSize; i++) From de988ea4c7c86f56275e1a62244b9261a56ffe68 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Mon, 4 Mar 2024 12:34:33 -0500 Subject: [PATCH 24/46] Formatting --- source/adios2/toolkit/derived/Function.tcc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/adios2/toolkit/derived/Function.tcc b/source/adios2/toolkit/derived/Function.tcc index b96200aa02..077ad1e933 100644 --- a/source/adios2/toolkit/derived/Function.tcc +++ b/source/adios2/toolkit/derived/Function.tcc @@ -22,7 +22,7 @@ T *ApplyOneToOne(std::vector inputData, size_t dataSize, std::cout << "Allocation failed for the derived data" << std::endl; // TODO - throw an exception } - memset((void*)outValues, 0, dataSize * sizeof(T)); + memset((void *)outValues, 0, dataSize * sizeof(T)); for (auto &variable : inputData) { for (size_t i = 0; i < dataSize; i++) From 5f8cc22b84bc8554b533ca7e83311728369e39c2 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Wed, 6 Mar 2024 16:19:32 -0500 Subject: [PATCH 25/46] Fixing CI warnings: ignore warnings on generated files --- source/adios2/CMakeLists.txt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index dd08f8e56b..d587fc0722 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -156,6 +156,11 @@ if (ADIOS2_HAVE_Derived_Variable) DEFINES_FILE ${CMAKE_CURRENT_BINARY_DIR}/lexer.h) ADD_FLEX_BISON_DEPENDENCY(MyScanner MyParser) endif() + if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU") + SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp PROPERTIES COMPILE_FLAGS -Wno-sign-compare) + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") + SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/parser.cpp PROPERTIES COMPILE_FLAGS -Wno-unused-but-set-variable) + endif() add_library(adios2_core_derived ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp From 1fad5368992d3de41ff2f0a30b044b5a3e1d804b Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 7 Mar 2024 23:41:48 +0000 Subject: [PATCH 26/46] Windows --- cmake/ADIOSBisonFlexSub.cmake | 16 +- source/adios2/CMakeLists.txt | 4 + source/adios2/toolkit/derived/Expression.cpp | 1 + source/adios2/toolkit/derived/Function.cpp | 2 +- .../parser/pregen-source/Linux/lexer.cpp | 1898 ----------------- .../parser/pregen-source/Linux/lexer.h | 478 ----- .../parser/pregen-source/Windows/location.hh | 306 --- .../parser/pregen-source/Windows/parser.cpp | 1414 ------------ .../parser/pregen-source/Windows/parser.h | 1626 -------------- .../pregen-source/{Windows => }/lexer.cpp | 1 - .../pregen-source/{Windows => }/lexer.h | 0 .../pregen-source/{Linux => }/location.hh | 0 .../pregen-source/{Linux => }/parser.cpp | 0 .../parser/pregen-source/{Linux => }/parser.h | 0 .../derived/TestBPDerivedCorrectness.cpp | 6 +- 15 files changed, 10 insertions(+), 5742 deletions(-) delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.cpp delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.h delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp delete mode 100644 source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h rename source/adios2/toolkit/derived/parser/pregen-source/{Windows => }/lexer.cpp (99%) rename source/adios2/toolkit/derived/parser/pregen-source/{Windows => }/lexer.h (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{Linux => }/location.hh (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{Linux => }/parser.cpp (100%) rename source/adios2/toolkit/derived/parser/pregen-source/{Linux => }/parser.h (100%) diff --git a/cmake/ADIOSBisonFlexSub.cmake b/cmake/ADIOSBisonFlexSub.cmake index f2f2f50a04..2a95e1bbcd 100644 --- a/cmake/ADIOSBisonFlexSub.cmake +++ b/cmake/ADIOSBisonFlexSub.cmake @@ -1,20 +1,6 @@ FUNCTION (SETUP_ADIOS_BISON_FLEX_SUB) -IF ((${CMAKE_SYSTEM_NAME} STREQUAL "Darwin") OR - (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")) - set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source/Linux") -elseif (${CMAKE_SYSTEM_NAME} STREQUAL "Windows") - set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source/Windows") -else() - if (NOT BISON_FOUND) - message (FATAL_ERROR "Bison was not found and no pregenerated Bison/Flex" - "source is available for ${CMAKE_SYSTEM_NAME}. Please install Bison or Yacc") - - else() - message (FATAL_ERROR "Flex was not found and no pregenerated Bison/Flex" - "source is available for ${CMAKE_SYSTEM_NAME}. Please install Bison or Yacc") - endif() -ENDIF() +set (BISON_FLEX_PRECOMPILE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/toolkit/derived/parser/pregen-source") ADD_CUSTOM_COMMAND(OUTPUT parser.cpp COMMAND ${CMAKE_COMMAND} -E copy ${BISON_FLEX_PRECOMPILE_DIR}/parser.cpp ${CMAKE_CURRENT_BINARY_DIR} diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index d587fc0722..cfc22b8151 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -136,6 +136,7 @@ if (ADIOS2_HAVE_Derived_Variable) toolkit/derived/Function.cpp toolkit/derived/Function.tcc toolkit/derived/ExprHelper.h) set_target_properties(adios2_core PROPERTIES + COMPILE_FLAGS "/wd4005 /wd4065 /wd4267 -DYY_NO_UNISTD_H" INCLUDE_DIRECTORIES "$;$") find_package(BISON "3.8.2") find_package(FLEX) @@ -173,6 +174,9 @@ if (ADIOS2_HAVE_Derived_Variable) OUTPUT_NAME adios2${ADIOS2_LIBRARY_SUFFIX}_core_derived) target_link_libraries(adios2_core PRIVATE adios2_core_derived) set(maybe_adios2_core_derived adios2_core_derived) + if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + set_target_properties(adios2_core_derived PROPERTIES COMPILE_FLAGS "/wd4005 /wd4267 /wd4065 -DYY_NO_UNISTD_H") + endif() endif() set(maybe_adios2_core_cuda) diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index b33757cdc0..820161922e 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -18,6 +18,7 @@ adios2::detail::ExpressionOperator convert_op(std::string opname) } catch (std::out_of_range &e) { + (void)e; // use e helper::Throw("Derived", "ExprHelper", "get_op", "Parser cannot recognize operator '" + opname + "'."); } diff --git a/source/adios2/toolkit/derived/Function.cpp b/source/adios2/toolkit/derived/Function.cpp index c524ac8c15..0e49d9a6a7 100644 --- a/source/adios2/toolkit/derived/Function.cpp +++ b/source/adios2/toolkit/derived/Function.cpp @@ -39,7 +39,7 @@ DerivedData MagnitudeFunc(std::vector inputData, DataType type) T *magValues = ApplyOneToOne(inputData, dataSize, [](T a, T b) { return a + b * b; }); \ for (size_t i = 0; i < dataSize; i++) \ { \ - magValues[i] = std::sqrt(magValues[i]); \ + magValues[i] = (T) std::sqrt(magValues[i]); \ } \ return DerivedData({(void *)magValues, inputData[0].Start, inputData[0].Count}); \ } diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.cpp deleted file mode 100644 index 74ae734d89..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.cpp +++ /dev/null @@ -1,1898 +0,0 @@ -#line 1 "lexer.cpp" - -#line 3 "lexer.cpp" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -typedef uint64_t flex_uint64_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* Returned upon end-of-file. */ -#define YY_NULL 0 - -/* Promotes a possibly negative, possibly signed char to an - * integer in range [0..255] for use as an array index. - */ -#define YY_SC_TO_UI(c) ((YY_CHAR) (c)) - -/* Enter a start condition. This macro really ought to take a parameter, - * but we do it the disgusting crufty way forced on us by the ()-less - * definition of BEGIN. - */ -#define BEGIN (yy_start) = 1 + 2 * -/* Translate the current start state into a value that can be later handed - * to BEGIN to return to the state. The YYSTATE alias is for lex - * compatibility. - */ -#define YY_START (((yy_start) - 1) / 2) -#define YYSTATE YY_START -/* Action number for EOF rule of a given start state. */ -#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1) -/* Special action meaning "start processing a new file". */ -#define YY_NEW_FILE yyrestart( yyin ) -#define YY_END_OF_BUFFER_CHAR 0 - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -/* The state buf must be large enough to hold one state per character in the main buffer. - */ -#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type)) - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -extern yy_size_t yyleng; - -extern FILE *yyin, *yyout; - -#define EOB_ACT_CONTINUE_SCAN 0 -#define EOB_ACT_END_OF_FILE 1 -#define EOB_ACT_LAST_MATCH 2 - - #define YY_LESS_LINENO(n) - #define YY_LINENO_REWIND_TO(ptr) - -/* Return all but the first "n" matched characters back to the input stream. */ -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - *yy_cp = (yy_hold_char); \ - YY_RESTORE_YY_MORE_OFFSET \ - (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \ - YY_DO_BEFORE_ACTION; /* set up yytext again */ \ - } \ - while ( 0 ) -#define unput(c) yyunput( c, (yytext_ptr) ) - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - yy_size_t yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - -#define YY_BUFFER_NEW 0 -#define YY_BUFFER_NORMAL 1 - /* When an EOF's been seen but there's still some text to process - * then we mark the buffer as YY_EOF_PENDING, to indicate that we - * shouldn't try reading from the input source any more. We might - * still have a bunch of tokens to match, though, because of - * possible backing-up. - * - * When we actually see the EOF, we change the status to "new" - * (via yyrestart()), so that the user can continue scanning by - * just pointing yyin at a new input file. - */ -#define YY_BUFFER_EOF_PENDING 2 - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -/* Stack of input buffers. */ -static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */ -static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */ -static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ - -/* We provide macros for accessing buffer states in case in the - * future we want to put the buffer states in a more general - * "scanner state". - * - * Returns the top of the stack, or NULL. - */ -#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \ - ? (yy_buffer_stack)[(yy_buffer_stack_top)] \ - : NULL) -/* Same as previous macro, but useful when we know that the buffer stack is not - * NULL or when we need an lvalue. For internal use only. - */ -#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)] - -/* yy_hold_char holds the character lost when yytext is formed. */ -static char yy_hold_char; -static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ -yy_size_t yyleng; - -/* Points to current character in buffer. */ -static char *yy_c_buf_p = NULL; -static int yy_init = 0; /* whether we need to initialize */ -static int yy_start = 0; /* start state number */ - -/* Flag which is used to allow yywrap()'s to do buffer switches - * instead of setting up a fresh yyin. A bit of a hack ... - */ -static int yy_did_buffer_switch_on_eof; - -void yyrestart ( FILE *input_file ); -void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); -void yy_delete_buffer ( YY_BUFFER_STATE b ); -void yy_flush_buffer ( YY_BUFFER_STATE b ); -void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); -void yypop_buffer_state ( void ); - -static void yyensure_buffer_stack ( void ); -static void yy_load_buffer_state ( void ); -static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); -#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER ) - -YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); - -void *yyalloc ( yy_size_t ); -void *yyrealloc ( void *, yy_size_t ); -void yyfree ( void * ); - -#define yy_new_buffer yy_create_buffer -#define yy_set_interactive(is_interactive) \ - { \ - if ( ! YY_CURRENT_BUFFER ){ \ - yyensure_buffer_stack (); \ - YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer( yyin, YY_BUF_SIZE ); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \ - } -#define yy_set_bol(at_bol) \ - { \ - if ( ! YY_CURRENT_BUFFER ){\ - yyensure_buffer_stack (); \ - YY_CURRENT_BUFFER_LVALUE = \ - yy_create_buffer( yyin, YY_BUF_SIZE ); \ - } \ - YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \ - } -#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol) - -/* Begin user sect3 */ - -#define yywrap() (/*CONSTCOND*/1) -#define YY_SKIP_YYWRAP -typedef flex_uint8_t YY_CHAR; - -FILE *yyin = NULL, *yyout = NULL; - -typedef int yy_state_type; - -extern int yylineno; -int yylineno = 1; - -extern char *yytext; -#ifdef yytext_ptr -#undef yytext_ptr -#endif -#define yytext_ptr yytext - -static yy_state_type yy_get_previous_state ( void ); -static yy_state_type yy_try_NUL_trans ( yy_state_type current_state ); -static int yy_get_next_buffer ( void ); -static void yynoreturn yy_fatal_error ( const char* msg ); - -/* Done after the current pattern has been matched and before the - * corresponding action - sets up yytext. - */ -#define YY_DO_BEFORE_ACTION \ - (yytext_ptr) = yy_bp; \ - yyleng = (yy_size_t) (yy_cp - yy_bp); \ - (yy_hold_char) = *yy_cp; \ - *yy_cp = '\0'; \ - (yy_c_buf_p) = yy_cp; -#define YY_NUM_RULES 15 -#define YY_END_OF_BUFFER 16 -/* This struct is not used in this scanner, - but its presence is necessary. */ -struct yy_trans_info - { - flex_int32_t yy_verify; - flex_int32_t yy_nxt; - }; -static const flex_int16_t yy_accept[23] = - { 0, - 0, 0, 16, 14, 1, 2, 6, 7, 11, 4, - 10, 5, 3, 12, 8, 9, 1, 2, 10, 13, - 12, 0 - } ; - -static const YY_CHAR yy_ec[256] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, - 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 2, 1, 1, 1, 1, 1, 1, 1, 4, - 5, 6, 6, 7, 8, 9, 8, 10, 10, 10, - 10, 10, 10, 10, 10, 10, 10, 11, 1, 1, - 12, 1, 1, 1, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 14, 9, 15, 6, 16, 1, 13, 13, 13, 13, - - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, - 13, 13, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1 - } ; - -static const YY_CHAR yy_meta[17] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, - 1, 1, 2, 1, 1, 2 - } ; - -static const flex_int16_t yy_base[25] = - { 0, - 0, 0, 29, 30, 26, 24, 30, 30, 30, 30, - 16, 30, 30, 9, 30, 30, 23, 21, 13, 0, - 11, 30, 20, 19 - } ; - -static const flex_int16_t yy_def[25] = - { 0, - 22, 1, 22, 22, 22, 22, 22, 22, 22, 22, - 22, 22, 22, 23, 22, 22, 22, 22, 22, 24, - 23, 0, 22, 22 - } ; - -static const flex_int16_t yy_nxt[47] = - { 0, - 4, 5, 6, 7, 8, 9, 10, 9, 4, 11, - 12, 13, 14, 15, 16, 4, 20, 20, 20, 20, - 20, 21, 19, 18, 17, 19, 18, 17, 22, 3, - 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, - 22, 22, 22, 22, 22, 22 - } ; - -static const flex_int16_t yy_chk[47] = - { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 1, 1, 14, 14, 21, 21, - 24, 23, 19, 18, 17, 11, 6, 5, 3, 22, - 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, - 22, 22, 22, 22, 22, 22 - } ; - -static yy_state_type yy_last_accepting_state; -static char *yy_last_accepting_cpos; - -extern int yy_flex_debug; -int yy_flex_debug = 0; - -/* The intent behind this definition is that it'll catch - * any uses of REJECT which flex missed. - */ -#define REJECT reject_used_but_not_detected -#define yymore() yymore_used_but_not_detected -#define YY_MORE_ADJ 0 -#define YY_RESTORE_YY_MORE_OFFSET -char *yytext; -#line 1 "..//lexer.l" -#line 2 "..//lexer.l" -#include -#include -#include -#include // strerror -#include -#include "ASTDriver.h" -#include "parser.h" -#line 468 "lexer.cpp" -#line 12 "..//lexer.l" -#if defined __clang__ -# define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) -#endif - -// Clang and ICC like to pretend they are GCC. -#if defined __GNUC__ && !defined __clang__ && !defined __ICC -# define GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) -#endif - -// Pacify warnings in yy_init_buffer (observed with Flex 2.6.4) -// and GCC 6.4.0, 7.3.0 with -O3. -#if defined GCC_VERSION && 600 <= GCC_VERSION -# pragma GCC diagnostic ignored "-Wnull-dereference" -#endif - -// This example uses Flex's C back end, yet compiles it as C++. -// So expect warnings about C style casts and NULL. -#if defined CLANG_VERSION && 500 <= CLANG_VERSION -# pragma clang diagnostic ignored "-Wold-style-cast" -# pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant" -#elif defined GCC_VERSION && 407 <= GCC_VERSION -# pragma GCC diagnostic ignored "-Wold-style-cast" -# pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant" -#endif - -#define FLEX_VERSION (YY_FLEX_MAJOR_VERSION * 100 + YY_FLEX_MINOR_VERSION) - -// Old versions of Flex (2.5.35) generate an incomplete documentation comment. -// -// In file included from src/scan-code-c.c:3: -// src/scan-code.c:2198:21: error: empty paragraph passed to '@param' command -// [-Werror,-Wdocumentation] -// * @param line_number -// ~~~~~~~~~~~~~~~~~^ -// 1 error generated. -#if FLEX_VERSION < 206 && defined CLANG_VERSION -# pragma clang diagnostic ignored "-Wdocumentation" -#endif - -// Old versions of Flex (2.5.35) use 'register'. Warnings introduced in -// GCC 7 and Clang 6. -#if FLEX_VERSION < 206 -# if defined CLANG_VERSION && 600 <= CLANG_VERSION -# pragma clang diagnostic ignored "-Wdeprecated-register" -# elif defined GCC_VERSION && 700 <= GCC_VERSION -# pragma GCC diagnostic ignored "-Wregister" -# endif -#endif - -#if FLEX_VERSION < 206 -# if defined CLANG_VERSION -# pragma clang diagnostic ignored "-Wconversion" -# pragma clang diagnostic ignored "-Wdocumentation" -# pragma clang diagnostic ignored "-Wshorten-64-to-32" -# pragma clang diagnostic ignored "-Wsign-conversion" -# elif defined GCC_VERSION -# pragma GCC diagnostic ignored "-Wconversion" -# pragma GCC diagnostic ignored "-Wsign-conversion" -# endif -#endif - -// Flex 2.6.4, GCC 9 -// warning: useless cast to type 'int' [-Wuseless-cast] -// 1361 | YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); -// | ^ -#if defined GCC_VERSION && 900 <= GCC_VERSION -# pragma GCC diagnostic ignored "-Wuseless-cast" -#endif -#line 538 "lexer.cpp" -#define YY_NO_INPUT 1 -#line 85 "..//lexer.l" - // A number symbol corresponding to the value in S. - adios2::detail::parser::symbol_type - make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); -#line 544 "lexer.cpp" -#line 97 "..//lexer.l" - // Code run each time a pattern is matched. - # define YY_USER_ACTION loc.columns (yyleng); -#line 548 "lexer.cpp" -#line 549 "lexer.cpp" - -#define INITIAL 0 - -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -static int yy_init_globals ( void ); - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy ( void ); - -int yyget_debug ( void ); - -void yyset_debug ( int debug_flag ); - -YY_EXTRA_TYPE yyget_extra ( void ); - -void yyset_extra ( YY_EXTRA_TYPE user_defined ); - -FILE *yyget_in ( void ); - -void yyset_in ( FILE * _in_str ); - -FILE *yyget_out ( void ); - -void yyset_out ( FILE * _out_str ); - - yy_size_t yyget_leng ( void ); - -char *yyget_text ( void ); - -int yyget_lineno ( void ); - -void yyset_lineno ( int _line_number ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap ( void ); -#else -extern int yywrap ( void ); -#endif -#endif - -#ifndef YY_NO_UNPUT - -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy ( char *, const char *, int ); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen ( const char * ); -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus -static int yyinput ( void ); -#else -static int input ( void ); -#endif - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Copy whatever the last rule matched to the standard output. */ -#ifndef ECHO -/* This used to be an fputs(), but since the string might contain NUL's, - * we now use fwrite(). - */ -#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0) -#endif - -/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL, - * is returned in "result". - */ -#ifndef YY_INPUT -#define YY_INPUT(buf,result,max_size) \ - if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ - { \ - int c = '*'; \ - yy_size_t n; \ - for ( n = 0; n < max_size && \ - (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ - buf[n] = (char) c; \ - if ( c == '\n' ) \ - buf[n++] = (char) c; \ - if ( c == EOF && ferror( yyin ) ) \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - result = n; \ - } \ - else \ - { \ - errno=0; \ - while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \ - { \ - if( errno != EINTR) \ - { \ - YY_FATAL_ERROR( "input in flex scanner failed" ); \ - break; \ - } \ - errno=0; \ - clearerr(yyin); \ - } \ - }\ -\ - -#endif - -/* No semi-colon after return; correct usage is to write "yyterminate();" - - * we don't want an extra ';' after the "return" because that will cause - * some compilers to complain about unreachable statements. - */ -#ifndef yyterminate -#define yyterminate() return YY_NULL -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Report a fatal error. */ -#ifndef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yy_fatal_error( msg ) -#endif - -/* end tables serialization structures and prototypes */ - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex (void); - -#define YY_DECL int yylex (void) -#endif /* !YY_DECL */ - -/* Code executed at the beginning of each rule, after yytext and yyleng - * have been set up. - */ -#ifndef YY_USER_ACTION -#define YY_USER_ACTION -#endif - -/* Code executed at the end of each rule. */ -#ifndef YY_BREAK -#define YY_BREAK /*LINTED*/break; -#endif - -#define YY_RULE_SETUP \ - YY_USER_ACTION - -/** The main scanner function which does all the work. - */ -YY_DECL -{ - yy_state_type yy_current_state; - char *yy_cp, *yy_bp; - int yy_act; - - if ( !(yy_init) ) - { - (yy_init) = 1; - -#ifdef YY_USER_INIT - YY_USER_INIT; -#endif - - if ( ! (yy_start) ) - (yy_start) = 1; /* first start state */ - - if ( ! yyin ) - yyin = stdin; - - if ( ! yyout ) - yyout = stdout; - - if ( ! YY_CURRENT_BUFFER ) { - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE ); - } - - yy_load_buffer_state( ); - } - - { -#line 100 "..//lexer.l" - - -#line 103 "..//lexer.l" - // A handy shortcut to the location held by the adios2::detail::ASTDriver. - adios2::detail::location& loc = drv.location; - // Code run each time yylex is called. - loc.step (); - -#line 773 "lexer.cpp" - - while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ - { - yy_cp = (yy_c_buf_p); - - /* Support of yytext. */ - *yy_cp = (yy_hold_char); - - /* yy_bp points to the position in yy_ch_buf of the start of - * the current run. - */ - yy_bp = yy_cp; - - yy_current_state = (yy_start); -yy_match: - do - { - YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 23 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - ++yy_cp; - } - while ( yy_current_state != 22 ); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - -yy_find_action: - yy_act = yy_accept[yy_current_state]; - - YY_DO_BEFORE_ACTION; - -do_action: /* This label is used only to access EOF actions. */ - - switch ( yy_act ) - { /* beginning of action switch */ - case 0: /* must back up */ - /* undo the effects of YY_DO_BEFORE_ACTION */ - *yy_cp = (yy_hold_char); - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - -case 1: -YY_RULE_SETUP -#line 108 "..//lexer.l" -loc.step (); - YY_BREAK -case 2: -/* rule 2 can match eol */ -YY_RULE_SETUP -#line 109 "..//lexer.l" -loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); - YY_BREAK -case 3: -YY_RULE_SETUP -#line 111 "..//lexer.l" -return adios2::detail::parser::make_ASSIGN (loc); - YY_BREAK -case 4: -YY_RULE_SETUP -#line 112 "..//lexer.l" -return adios2::detail::parser::make_COMMA (loc); - YY_BREAK -case 5: -YY_RULE_SETUP -#line 113 "..//lexer.l" -return adios2::detail::parser::make_COLON (loc); - YY_BREAK -case 6: -YY_RULE_SETUP -#line 114 "..//lexer.l" -return adios2::detail::parser::make_L_PAREN (loc); - YY_BREAK -case 7: -YY_RULE_SETUP -#line 115 "..//lexer.l" -return adios2::detail::parser::make_R_PAREN (loc); - YY_BREAK -case 8: -YY_RULE_SETUP -#line 116 "..//lexer.l" -return adios2::detail::parser::make_L_BRACE (loc); - YY_BREAK -case 9: -YY_RULE_SETUP -#line 117 "..//lexer.l" -return adios2::detail::parser::make_R_BRACE (loc); - YY_BREAK -case 10: -YY_RULE_SETUP -#line 119 "..//lexer.l" -return make_INT (yytext, loc); - YY_BREAK -case 11: -YY_RULE_SETUP -#line 120 "..//lexer.l" -return adios2::detail::parser::make_OPERATOR (yytext, loc); - YY_BREAK -case 12: -YY_RULE_SETUP -#line 121 "..//lexer.l" -return adios2::detail::parser::make_IDENTIFIER (yytext, loc); - YY_BREAK -case 13: -YY_RULE_SETUP -#line 122 "..//lexer.l" -return adios2::detail::parser::make_VARNAME (yytext, loc); - YY_BREAK -case 14: -YY_RULE_SETUP -#line 123 "..//lexer.l" -{ - throw adios2::detail::parser::syntax_error - (loc, "invalid character: " + std::string(yytext)); -} - YY_BREAK -case YY_STATE_EOF(INITIAL): -#line 127 "..//lexer.l" -return adios2::detail::parser::make_YYEOF (loc); - YY_BREAK -case 15: -YY_RULE_SETUP -#line 128 "..//lexer.l" -ECHO; - YY_BREAK -#line 909 "lexer.cpp" - - case YY_END_OF_BUFFER: - { - /* Amount of text matched not including the EOB char. */ - int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1; - - /* Undo the effects of YY_DO_BEFORE_ACTION. */ - *yy_cp = (yy_hold_char); - YY_RESTORE_YY_MORE_OFFSET - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW ) - { - /* We're scanning a new file or input source. It's - * possible that this happened because the user - * just pointed yyin at a new source and called - * yylex(). If so, then we have to assure - * consistency between YY_CURRENT_BUFFER and our - * globals. Here is the right place to do so, because - * this is the first action (other than possibly a - * back-up) that will match for the new input source. - */ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL; - } - - /* Note that here we test for yy_c_buf_p "<=" to the position - * of the first EOB in the buffer, since yy_c_buf_p will - * already have been incremented past the NUL character - * (since all states make transitions on EOB to the - * end-of-buffer state). Contrast this with the test - * in input(). - */ - if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - { /* This was really a NUL. */ - yy_state_type yy_next_state; - - (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - /* Okay, we're now positioned to make the NUL - * transition. We couldn't have - * yy_get_previous_state() go ahead and do it - * for us because it doesn't know how to deal - * with the possibility of jamming (and we don't - * want to build jamming into it because then it - * will run more slowly). - */ - - yy_next_state = yy_try_NUL_trans( yy_current_state ); - - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - - if ( yy_next_state ) - { - /* Consume the NUL. */ - yy_cp = ++(yy_c_buf_p); - yy_current_state = yy_next_state; - goto yy_match; - } - - else - { - yy_cp = (yy_last_accepting_cpos); - yy_current_state = (yy_last_accepting_state); - goto yy_find_action; - } - } - - else switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_END_OF_FILE: - { - (yy_did_buffer_switch_on_eof) = 0; - - if ( yywrap( ) ) - { - /* Note: because we've taken care in - * yy_get_next_buffer() to have set up - * yytext, we can now set up - * yy_c_buf_p so that if some total - * hoser (like flex itself) wants to - * call the scanner after we return the - * YY_NULL, it'll still work - another - * YY_NULL will get returned. - */ - (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ; - - yy_act = YY_STATE_EOF(YY_START); - goto do_action; - } - - else - { - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; - } - break; - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = - (yytext_ptr) + yy_amount_of_matched_text; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_match; - - case EOB_ACT_LAST_MATCH: - (yy_c_buf_p) = - &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)]; - - yy_current_state = yy_get_previous_state( ); - - yy_cp = (yy_c_buf_p); - yy_bp = (yytext_ptr) + YY_MORE_ADJ; - goto yy_find_action; - } - break; - } - - default: - YY_FATAL_ERROR( - "fatal flex scanner internal error--no action found" ); - } /* end of action switch */ - } /* end of scanning one token */ - } /* end of user's declarations */ -} /* end of yylex */ - -/* yy_get_next_buffer - try to read in a new buffer - * - * Returns a code representing an action: - * EOB_ACT_LAST_MATCH - - * EOB_ACT_CONTINUE_SCAN - continue scanning from current position - * EOB_ACT_END_OF_FILE - end of file - */ -static int yy_get_next_buffer (void) -{ - char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf; - char *source = (yytext_ptr); - int number_to_move, i; - int ret_val; - - if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] ) - YY_FATAL_ERROR( - "fatal flex scanner internal error--end of buffer missed" ); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 ) - { /* Don't try to fill the buffer, so this is an EOF. */ - if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 ) - { - /* We matched a single character, the EOB, so - * treat this as a final EOF. - */ - return EOB_ACT_END_OF_FILE; - } - - else - { - /* We matched some text prior to the EOB, first - * process it. - */ - return EOB_ACT_LAST_MATCH; - } - } - - /* Try to read more data. */ - - /* First move last chars to start of buffer. */ - number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1); - - for ( i = 0; i < number_to_move; ++i ) - *(dest++) = *(source++); - - if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING ) - /* don't do the read, it's not guaranteed to return an EOF, - * just force an EOF - */ - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0; - - else - { - yy_size_t num_to_read = - YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; - - while ( num_to_read <= 0 ) - { /* Not enough room in the buffer - grow it. */ - - /* just a shorter name for the current buffer */ - YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE; - - int yy_c_buf_p_offset = - (int) ((yy_c_buf_p) - b->yy_ch_buf); - - if ( b->yy_is_our_buffer ) - { - yy_size_t new_size = b->yy_buf_size * 2; - - if ( new_size <= 0 ) - b->yy_buf_size += b->yy_buf_size / 8; - else - b->yy_buf_size *= 2; - - b->yy_ch_buf = (char *) - /* Include room in for 2 EOB chars. */ - yyrealloc( (void *) b->yy_ch_buf, - (yy_size_t) (b->yy_buf_size + 2) ); - } - else - /* Can't grow it, we don't own it. */ - b->yy_ch_buf = NULL; - - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( - "fatal error - scanner input buffer overflow" ); - - (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset]; - - num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - - number_to_move - 1; - - } - - if ( num_to_read > YY_READ_BUF_SIZE ) - num_to_read = YY_READ_BUF_SIZE; - - /* Read in more data. */ - YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]), - (yy_n_chars), num_to_read ); - - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - if ( (yy_n_chars) == 0 ) - { - if ( number_to_move == YY_MORE_ADJ ) - { - ret_val = EOB_ACT_END_OF_FILE; - yyrestart( yyin ); - } - - else - { - ret_val = EOB_ACT_LAST_MATCH; - YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = - YY_BUFFER_EOF_PENDING; - } - } - - else - ret_val = EOB_ACT_CONTINUE_SCAN; - - if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { - /* Extend the array by 50%, plus the number we really need. */ - yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( - (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); - if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" ); - /* "- 2" to take care of EOB's */ - YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2); - } - - (yy_n_chars) += number_to_move; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR; - YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR; - - (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0]; - - return ret_val; -} - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - - static yy_state_type yy_get_previous_state (void) -{ - yy_state_type yy_current_state; - char *yy_cp; - - yy_current_state = (yy_start); - - for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp ) - { - YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1); - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 23 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - } - - return yy_current_state; -} - -/* yy_try_NUL_trans - try to make a transition on the NUL character - * - * synopsis - * next_state = yy_try_NUL_trans( current_state ); - */ - static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state ) -{ - int yy_is_jam; - char *yy_cp = (yy_c_buf_p); - - YY_CHAR yy_c = 1; - if ( yy_accept[yy_current_state] ) - { - (yy_last_accepting_state) = yy_current_state; - (yy_last_accepting_cpos) = yy_cp; - } - while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) - { - yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 23 ) - yy_c = yy_meta[yy_c]; - } - yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 22); - - return yy_is_jam ? 0 : yy_current_state; -} - -#ifndef YY_NO_UNPUT - -#endif - -#ifndef YY_NO_INPUT -#ifdef __cplusplus - static int yyinput (void) -#else - static int input (void) -#endif - -{ - int c; - - *(yy_c_buf_p) = (yy_hold_char); - - if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR ) - { - /* yy_c_buf_p now points to the character we want to return. - * If this occurs *before* the EOB characters, then it's a - * valid NUL; if not, then we've hit the end of the buffer. - */ - if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] ) - /* This was really a NUL. */ - *(yy_c_buf_p) = '\0'; - - else - { /* need more input */ - yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); - ++(yy_c_buf_p); - - switch ( yy_get_next_buffer( ) ) - { - case EOB_ACT_LAST_MATCH: - /* This happens because yy_g_n_b() - * sees that we've accumulated a - * token and flags that we need to - * try matching the token before - * proceeding. But for input(), - * there's no matching to consider. - * So convert the EOB_ACT_LAST_MATCH - * to EOB_ACT_END_OF_FILE. - */ - - /* Reset buffer status. */ - yyrestart( yyin ); - - /*FALLTHROUGH*/ - - case EOB_ACT_END_OF_FILE: - { - if ( yywrap( ) ) - return 0; - - if ( ! (yy_did_buffer_switch_on_eof) ) - YY_NEW_FILE; -#ifdef __cplusplus - return yyinput(); -#else - return input(); -#endif - } - - case EOB_ACT_CONTINUE_SCAN: - (yy_c_buf_p) = (yytext_ptr) + offset; - break; - } - } - } - - c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */ - *(yy_c_buf_p) = '\0'; /* preserve yytext */ - (yy_hold_char) = *++(yy_c_buf_p); - - return c; -} -#endif /* ifndef YY_NO_INPUT */ - -/** Immediately switch to a different input stream. - * @param input_file A readable stream. - * - * @note This function does not reset the start condition to @c INITIAL . - */ - void yyrestart (FILE * input_file ) -{ - - if ( ! YY_CURRENT_BUFFER ){ - yyensure_buffer_stack (); - YY_CURRENT_BUFFER_LVALUE = - yy_create_buffer( yyin, YY_BUF_SIZE ); - } - - yy_init_buffer( YY_CURRENT_BUFFER, input_file ); - yy_load_buffer_state( ); -} - -/** Switch to a different input buffer. - * @param new_buffer The new input buffer. - * - */ - void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ) -{ - - /* TODO. We should be able to replace this entire function body - * with - * yypop_buffer_state(); - * yypush_buffer_state(new_buffer); - */ - yyensure_buffer_stack (); - if ( YY_CURRENT_BUFFER == new_buffer ) - return; - - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - YY_CURRENT_BUFFER_LVALUE = new_buffer; - yy_load_buffer_state( ); - - /* We don't actually know whether we did this switch during - * EOF (yywrap()) processing, but the only time this flag - * is looked at is after yywrap() is called, so it's safe - * to go ahead and always set it. - */ - (yy_did_buffer_switch_on_eof) = 1; -} - -static void yy_load_buffer_state (void) -{ - (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars; - (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos; - yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file; - (yy_hold_char) = *(yy_c_buf_p); -} - -/** Allocate and initialize an input buffer state. - * @param file A readable stream. - * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE. - * - * @return the allocated buffer state. - */ - YY_BUFFER_STATE yy_create_buffer (FILE * file, int size ) -{ - YY_BUFFER_STATE b; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_buf_size = size; - - /* yy_ch_buf has to be 2 characters longer than the size given because - * we need to put in 2 end-of-buffer characters. - */ - b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) ); - if ( ! b->yy_ch_buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" ); - - b->yy_is_our_buffer = 1; - - yy_init_buffer( b, file ); - - return b; -} - -/** Destroy the buffer. - * @param b a buffer created with yy_create_buffer() - * - */ - void yy_delete_buffer (YY_BUFFER_STATE b ) -{ - - if ( ! b ) - return; - - if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */ - YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0; - - if ( b->yy_is_our_buffer ) - yyfree( (void *) b->yy_ch_buf ); - - yyfree( (void *) b ); -} - -/* Initializes or reinitializes a buffer. - * This function is sometimes called more than once on the same buffer, - * such as during a yyrestart() or at EOF. - */ - static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file ) - -{ - int oerrno = errno; - - yy_flush_buffer( b ); - - b->yy_input_file = file; - b->yy_fill_buffer = 1; - - /* If b is the current buffer, then yy_init_buffer was _probably_ - * called from yyrestart() or through yy_get_next_buffer. - * In that case, we don't want to reset the lineno or column. - */ - if (b != YY_CURRENT_BUFFER){ - b->yy_bs_lineno = 1; - b->yy_bs_column = 0; - } - - b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0; - - errno = oerrno; -} - -/** Discard all buffered characters. On the next scan, YY_INPUT will be called. - * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. - * - */ - void yy_flush_buffer (YY_BUFFER_STATE b ) -{ - if ( ! b ) - return; - - b->yy_n_chars = 0; - - /* We always need two end-of-buffer characters. The first causes - * a transition to the end-of-buffer state. The second causes - * a jam in that state. - */ - b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR; - b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR; - - b->yy_buf_pos = &b->yy_ch_buf[0]; - - b->yy_at_bol = 1; - b->yy_buffer_status = YY_BUFFER_NEW; - - if ( b == YY_CURRENT_BUFFER ) - yy_load_buffer_state( ); -} - -/** Pushes the new state onto the stack. The new state becomes - * the current state. This function will allocate the stack - * if necessary. - * @param new_buffer The new state. - * - */ -void yypush_buffer_state (YY_BUFFER_STATE new_buffer ) -{ - if (new_buffer == NULL) - return; - - yyensure_buffer_stack(); - - /* This block is copied from yy_switch_to_buffer. */ - if ( YY_CURRENT_BUFFER ) - { - /* Flush out information for old buffer. */ - *(yy_c_buf_p) = (yy_hold_char); - YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p); - YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars); - } - - /* Only push if top exists. Otherwise, replace top. */ - if (YY_CURRENT_BUFFER) - (yy_buffer_stack_top)++; - YY_CURRENT_BUFFER_LVALUE = new_buffer; - - /* copied from yy_switch_to_buffer. */ - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; -} - -/** Removes and deletes the top of the stack, if present. - * The next element becomes the new top. - * - */ -void yypop_buffer_state (void) -{ - if (!YY_CURRENT_BUFFER) - return; - - yy_delete_buffer(YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - if ((yy_buffer_stack_top) > 0) - --(yy_buffer_stack_top); - - if (YY_CURRENT_BUFFER) { - yy_load_buffer_state( ); - (yy_did_buffer_switch_on_eof) = 1; - } -} - -/* Allocates the stack if it does not exist. - * Guarantees space for at least one push. - */ -static void yyensure_buffer_stack (void) -{ - yy_size_t num_to_alloc; - - if (!(yy_buffer_stack)) { - - /* First allocation is just for 2 elements, since we don't know if this - * scanner will even need a stack. We use 2 instead of 1 to avoid an - * immediate realloc on the next call. - */ - num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */ - (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc - (num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*)); - - (yy_buffer_stack_max) = num_to_alloc; - (yy_buffer_stack_top) = 0; - return; - } - - if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){ - - /* Increase the buffer to prepare for a possible push. */ - yy_size_t grow_size = 8 /* arbitrary grow size */; - - num_to_alloc = (yy_buffer_stack_max) + grow_size; - (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc - ((yy_buffer_stack), - num_to_alloc * sizeof(struct yy_buffer_state*) - ); - if ( ! (yy_buffer_stack) ) - YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" ); - - /* zero only the new slots.*/ - memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*)); - (yy_buffer_stack_max) = num_to_alloc; - } -} - -/** Setup the input buffer state to scan directly from a user-specified character buffer. - * @param base the character buffer - * @param size the size in bytes of the character buffer - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size ) -{ - YY_BUFFER_STATE b; - - if ( size < 2 || - base[size-2] != YY_END_OF_BUFFER_CHAR || - base[size-1] != YY_END_OF_BUFFER_CHAR ) - /* They forgot to leave room for the EOB's. */ - return NULL; - - b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) ); - if ( ! b ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" ); - - b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */ - b->yy_buf_pos = b->yy_ch_buf = base; - b->yy_is_our_buffer = 0; - b->yy_input_file = NULL; - b->yy_n_chars = b->yy_buf_size; - b->yy_is_interactive = 0; - b->yy_at_bol = 1; - b->yy_fill_buffer = 0; - b->yy_buffer_status = YY_BUFFER_NEW; - - yy_switch_to_buffer( b ); - - return b; -} - -/** Setup the input buffer state to scan a string. The next call to yylex() will - * scan from a @e copy of @a str. - * @param yystr a NUL-terminated string to scan - * - * @return the newly allocated buffer state object. - * @note If you want to scan bytes that may contain NUL values, then use - * yy_scan_bytes() instead. - */ -YY_BUFFER_STATE yy_scan_string (const char * yystr ) -{ - - return yy_scan_bytes( yystr, (int) strlen(yystr) ); -} - -/** Setup the input buffer state to scan the given bytes. The next call to yylex() will - * scan from a @e copy of @a bytes. - * @param yybytes the byte buffer to scan - * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes. - * - * @return the newly allocated buffer state object. - */ -YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, yy_size_t _yybytes_len ) -{ - YY_BUFFER_STATE b; - char *buf; - yy_size_t n; - yy_size_t i; - - /* Get memory for full buffer, including space for trailing EOB's. */ - n = (yy_size_t) (_yybytes_len + 2); - buf = (char *) yyalloc( n ); - if ( ! buf ) - YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" ); - - for ( i = 0; i < _yybytes_len; ++i ) - buf[i] = yybytes[i]; - - buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR; - - b = yy_scan_buffer( buf, n ); - if ( ! b ) - YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" ); - - /* It's okay to grow etc. this buffer, and we should throw it - * away when we're done. - */ - b->yy_is_our_buffer = 1; - - return b; -} - -#ifndef YY_EXIT_FAILURE -#define YY_EXIT_FAILURE 2 -#endif - -static void yynoreturn yy_fatal_error (const char* msg ) -{ - fprintf( stderr, "%s\n", msg ); - exit( YY_EXIT_FAILURE ); -} - -/* Redefine yyless() so it works in section 3 code. */ - -#undef yyless -#define yyless(n) \ - do \ - { \ - /* Undo effects of setting up yytext. */ \ - yy_size_t yyless_macro_arg = (n); \ - YY_LESS_LINENO(yyless_macro_arg);\ - yytext[yyleng] = (yy_hold_char); \ - (yy_c_buf_p) = yytext + yyless_macro_arg; \ - (yy_hold_char) = *(yy_c_buf_p); \ - *(yy_c_buf_p) = '\0'; \ - yyleng = yyless_macro_arg; \ - } \ - while ( 0 ) - -/* Accessor methods (get/set functions) to struct members. */ - -/** Get the current line number. - * - */ -int yyget_lineno (void) -{ - - return yylineno; -} - -/** Get the input stream. - * - */ -FILE *yyget_in (void) -{ - return yyin; -} - -/** Get the output stream. - * - */ -FILE *yyget_out (void) -{ - return yyout; -} - -/** Get the length of the current token. - * - */ -yy_size_t yyget_leng (void) -{ - return yyleng; -} - -/** Get the current token. - * - */ - -char *yyget_text (void) -{ - return yytext; -} - -/** Set the current line number. - * @param _line_number line number - * - */ -void yyset_lineno (int _line_number ) -{ - - yylineno = _line_number; -} - -/** Set the input stream. This does not discard the current - * input buffer. - * @param _in_str A readable stream. - * - * @see yy_switch_to_buffer - */ -void yyset_in (FILE * _in_str ) -{ - yyin = _in_str ; -} - -void yyset_out (FILE * _out_str ) -{ - yyout = _out_str ; -} - -int yyget_debug (void) -{ - return yy_flex_debug; -} - -void yyset_debug (int _bdebug ) -{ - yy_flex_debug = _bdebug ; -} - -static int yy_init_globals (void) -{ - /* Initialization is the same as for the non-reentrant scanner. - * This function is called from yylex_destroy(), so don't allocate here. - */ - - (yy_buffer_stack) = NULL; - (yy_buffer_stack_top) = 0; - (yy_buffer_stack_max) = 0; - (yy_c_buf_p) = NULL; - (yy_init) = 0; - (yy_start) = 0; - -/* Defined in main.c */ -#ifdef YY_STDINIT - yyin = stdin; - yyout = stdout; -#else - yyin = NULL; - yyout = NULL; -#endif - - /* For future reference: Set errno on error, since we are called by - * yylex_init() - */ - return 0; -} - -/* yylex_destroy is for both reentrant and non-reentrant scanners. */ -int yylex_destroy (void) -{ - - /* Pop the buffer stack, destroying each element. */ - while(YY_CURRENT_BUFFER){ - yy_delete_buffer( YY_CURRENT_BUFFER ); - YY_CURRENT_BUFFER_LVALUE = NULL; - yypop_buffer_state(); - } - - /* Destroy the stack itself. */ - yyfree((yy_buffer_stack) ); - (yy_buffer_stack) = NULL; - - /* Reset the globals. This is important in a non-reentrant scanner so the next time - * yylex() is called, initialization will occur. */ - yy_init_globals( ); - - return 0; -} - -/* - * Internal utility routines. - */ - -#ifndef yytext_ptr -static void yy_flex_strncpy (char* s1, const char * s2, int n ) -{ - - int i; - for ( i = 0; i < n; ++i ) - s1[i] = s2[i]; -} -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen (const char * s ) -{ - int n; - for ( n = 0; s[n]; ++n ) - ; - - return n; -} -#endif - -void *yyalloc (yy_size_t size ) -{ - return malloc(size); -} - -void *yyrealloc (void * ptr, yy_size_t size ) -{ - - /* The cast to (char *) in the following accommodates both - * implementations that use char* generic pointers, and those - * that use void* generic pointers. It works with the latter - * because both ANSI C and C++ allow castless assignment from - * any pointer type to void*, and deal with argument conversions - * as though doing an assignment. - */ - return realloc(ptr, size); -} - -void yyfree (void * ptr ) -{ - free( (char *) ptr ); /* see yyrealloc() for (char *) cast */ -} - -#define YYTABLES_NAME "yytables" - -#line 128 "..//lexer.l" - - -adios2::detail::parser::symbol_type -make_INT (const std::string &s, const adios2::detail::parser::location_type& loc) -{ - errno = 0; - long n = strtol (s.c_str(), NULL, 10); - if (! (INT_MIN <= n && n <= INT_MAX && errno != ERANGE)) - throw adios2::detail::parser::syntax_error (loc, "integer is out of range: " + s); - return adios2::detail::parser::make_INT ((int) n, loc); -} - -adios2::detail::ASTNode* -adios2::detail::ASTDriver::parse (const std::string input) -{ - adios2::detail::parser parse (*this); - yy_scan_string(input.c_str()); - parse.set_debug_level (trace_parsing); - parse (); - return getAST(); -} - diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.h deleted file mode 100644 index 5e5e9be909..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/Linux/lexer.h +++ /dev/null @@ -1,478 +0,0 @@ -#ifndef yyHEADER_H -#define yyHEADER_H 1 -#define yyIN_HEADER 1 - -#line 5 "lexer.h" - -#line 7 "lexer.h" - -#define YY_INT_ALIGNED short int - -/* A lexical scanner generated by flex */ - -#define FLEX_SCANNER -#define YY_FLEX_MAJOR_VERSION 2 -#define YY_FLEX_MINOR_VERSION 6 -#define YY_FLEX_SUBMINOR_VERSION 4 -#if YY_FLEX_SUBMINOR_VERSION > 0 -#define FLEX_BETA -#endif - -/* First, we deal with platform-specific or compiler-specific issues. */ - -/* begin standard C headers. */ -#include -#include -#include -#include - -/* end standard C headers. */ - -/* flex integer type definitions */ - -#ifndef FLEXINT_H -#define FLEXINT_H - -/* C99 systems have . Non-C99 systems may or may not. */ - -#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L - -/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h, - * if you want the limit (max/min) macros for int types. - */ -#ifndef __STDC_LIMIT_MACROS -#define __STDC_LIMIT_MACROS 1 -#endif - -#include -typedef int8_t flex_int8_t; -typedef uint8_t flex_uint8_t; -typedef int16_t flex_int16_t; -typedef uint16_t flex_uint16_t; -typedef int32_t flex_int32_t; -typedef uint32_t flex_uint32_t; -typedef uint64_t flex_uint64_t; -#else -typedef signed char flex_int8_t; -typedef short int flex_int16_t; -typedef int flex_int32_t; -typedef unsigned char flex_uint8_t; -typedef unsigned short int flex_uint16_t; -typedef unsigned int flex_uint32_t; - -/* Limits of integral types. */ -#ifndef INT8_MIN -#define INT8_MIN (-128) -#endif -#ifndef INT16_MIN -#define INT16_MIN (-32767-1) -#endif -#ifndef INT32_MIN -#define INT32_MIN (-2147483647-1) -#endif -#ifndef INT8_MAX -#define INT8_MAX (127) -#endif -#ifndef INT16_MAX -#define INT16_MAX (32767) -#endif -#ifndef INT32_MAX -#define INT32_MAX (2147483647) -#endif -#ifndef UINT8_MAX -#define UINT8_MAX (255U) -#endif -#ifndef UINT16_MAX -#define UINT16_MAX (65535U) -#endif -#ifndef UINT32_MAX -#define UINT32_MAX (4294967295U) -#endif - -#ifndef SIZE_MAX -#define SIZE_MAX (~(size_t)0) -#endif - -#endif /* ! C99 */ - -#endif /* ! FLEXINT_H */ - -/* begin standard C++ headers. */ - -/* TODO: this is always defined, so inline it */ -#define yyconst const - -#if defined(__GNUC__) && __GNUC__ >= 3 -#define yynoreturn __attribute__((__noreturn__)) -#else -#define yynoreturn -#endif - -/* Size of default input buffer. */ -#ifndef YY_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k. - * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case. - * Ditto for the __ia64__ case accordingly. - */ -#define YY_BUF_SIZE 32768 -#else -#define YY_BUF_SIZE 16384 -#endif /* __ia64__ */ -#endif - -#ifndef YY_TYPEDEF_YY_BUFFER_STATE -#define YY_TYPEDEF_YY_BUFFER_STATE -typedef struct yy_buffer_state *YY_BUFFER_STATE; -#endif - -#ifndef YY_TYPEDEF_YY_SIZE_T -#define YY_TYPEDEF_YY_SIZE_T -typedef size_t yy_size_t; -#endif - -extern yy_size_t yyleng; - -extern FILE *yyin, *yyout; - -#ifndef YY_STRUCT_YY_BUFFER_STATE -#define YY_STRUCT_YY_BUFFER_STATE -struct yy_buffer_state - { - FILE *yy_input_file; - - char *yy_ch_buf; /* input buffer */ - char *yy_buf_pos; /* current position in input buffer */ - - /* Size of input buffer in bytes, not including room for EOB - * characters. - */ - int yy_buf_size; - - /* Number of characters read into yy_ch_buf, not including EOB - * characters. - */ - yy_size_t yy_n_chars; - - /* Whether we "own" the buffer - i.e., we know we created it, - * and can realloc() it to grow it, and should free() it to - * delete it. - */ - int yy_is_our_buffer; - - /* Whether this is an "interactive" input source; if so, and - * if we're using stdio for input, then we want to use getc() - * instead of fread(), to make sure we stop fetching input after - * each newline. - */ - int yy_is_interactive; - - /* Whether we're considered to be at the beginning of a line. - * If so, '^' rules will be active on the next match, otherwise - * not. - */ - int yy_at_bol; - - int yy_bs_lineno; /**< The line count. */ - int yy_bs_column; /**< The column count. */ - - /* Whether to try to fill the input buffer when we reach the - * end of it. - */ - int yy_fill_buffer; - - int yy_buffer_status; - - }; -#endif /* !YY_STRUCT_YY_BUFFER_STATE */ - -void yyrestart ( FILE *input_file ); -void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ); -YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size ); -void yy_delete_buffer ( YY_BUFFER_STATE b ); -void yy_flush_buffer ( YY_BUFFER_STATE b ); -void yypush_buffer_state ( YY_BUFFER_STATE new_buffer ); -void yypop_buffer_state ( void ); - -YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); -YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); - -void *yyalloc ( yy_size_t ); -void *yyrealloc ( void *, yy_size_t ); -void yyfree ( void * ); - -/* Begin user sect3 */ - -#define yywrap() (/*CONSTCOND*/1) -#define YY_SKIP_YYWRAP - -extern int yylineno; - -extern char *yytext; -#ifdef yytext_ptr -#undef yytext_ptr -#endif -#define yytext_ptr yytext - -#ifdef YY_HEADER_EXPORT_START_CONDITIONS -#define INITIAL 0 - -#endif - -#ifndef YY_NO_UNISTD_H -/* Special case for "unistd.h", since it is non-ANSI. We include it way - * down here because we want the user's section 1 to have been scanned first. - * The user has a chance to override it with an option. - */ -#include -#endif - -#ifndef YY_EXTRA_TYPE -#define YY_EXTRA_TYPE void * -#endif - -/* Accessor methods to globals. - These are made visible to non-reentrant scanners for convenience. */ - -int yylex_destroy ( void ); - -int yyget_debug ( void ); - -void yyset_debug ( int debug_flag ); - -YY_EXTRA_TYPE yyget_extra ( void ); - -void yyset_extra ( YY_EXTRA_TYPE user_defined ); - -FILE *yyget_in ( void ); - -void yyset_in ( FILE * _in_str ); - -FILE *yyget_out ( void ); - -void yyset_out ( FILE * _out_str ); - - yy_size_t yyget_leng ( void ); - -char *yyget_text ( void ); - -int yyget_lineno ( void ); - -void yyset_lineno ( int _line_number ); - -/* Macros after this point can all be overridden by user definitions in - * section 1. - */ - -#ifndef YY_SKIP_YYWRAP -#ifdef __cplusplus -extern "C" int yywrap ( void ); -#else -extern int yywrap ( void ); -#endif -#endif - -#ifndef yytext_ptr -static void yy_flex_strncpy ( char *, const char *, int ); -#endif - -#ifdef YY_NEED_STRLEN -static int yy_flex_strlen ( const char * ); -#endif - -#ifndef YY_NO_INPUT - -#endif - -/* Amount of stuff to slurp up with each read. */ -#ifndef YY_READ_BUF_SIZE -#ifdef __ia64__ -/* On IA-64, the buffer size is 16k, not 8k */ -#define YY_READ_BUF_SIZE 16384 -#else -#define YY_READ_BUF_SIZE 8192 -#endif /* __ia64__ */ -#endif - -/* Number of entries by which start-condition stack grows. */ -#ifndef YY_START_STACK_INCR -#define YY_START_STACK_INCR 25 -#endif - -/* Default declaration of generated scanner - a define so the user can - * easily add parameters. - */ -#ifndef YY_DECL -#define YY_DECL_IS_OURS 1 - -extern int yylex (void); - -#define YY_DECL int yylex (void) -#endif /* !YY_DECL */ - -/* yy_get_previous_state - get the state just before the EOB char was reached */ - -#undef YY_NEW_FILE -#undef YY_FLUSH_BUFFER -#undef yy_set_bol -#undef yy_new_buffer -#undef yy_set_interactive -#undef YY_DO_BEFORE_ACTION - -#ifdef YY_DECL_IS_OURS -#undef YY_DECL_IS_OURS -#undef YY_DECL -#endif - -#ifndef yy_create_buffer_ALREADY_DEFINED -#undef yy_create_buffer -#endif -#ifndef yy_delete_buffer_ALREADY_DEFINED -#undef yy_delete_buffer -#endif -#ifndef yy_scan_buffer_ALREADY_DEFINED -#undef yy_scan_buffer -#endif -#ifndef yy_scan_string_ALREADY_DEFINED -#undef yy_scan_string -#endif -#ifndef yy_scan_bytes_ALREADY_DEFINED -#undef yy_scan_bytes -#endif -#ifndef yy_init_buffer_ALREADY_DEFINED -#undef yy_init_buffer -#endif -#ifndef yy_flush_buffer_ALREADY_DEFINED -#undef yy_flush_buffer -#endif -#ifndef yy_load_buffer_state_ALREADY_DEFINED -#undef yy_load_buffer_state -#endif -#ifndef yy_switch_to_buffer_ALREADY_DEFINED -#undef yy_switch_to_buffer -#endif -#ifndef yypush_buffer_state_ALREADY_DEFINED -#undef yypush_buffer_state -#endif -#ifndef yypop_buffer_state_ALREADY_DEFINED -#undef yypop_buffer_state -#endif -#ifndef yyensure_buffer_stack_ALREADY_DEFINED -#undef yyensure_buffer_stack -#endif -#ifndef yylex_ALREADY_DEFINED -#undef yylex -#endif -#ifndef yyrestart_ALREADY_DEFINED -#undef yyrestart -#endif -#ifndef yylex_init_ALREADY_DEFINED -#undef yylex_init -#endif -#ifndef yylex_init_extra_ALREADY_DEFINED -#undef yylex_init_extra -#endif -#ifndef yylex_destroy_ALREADY_DEFINED -#undef yylex_destroy -#endif -#ifndef yyget_debug_ALREADY_DEFINED -#undef yyget_debug -#endif -#ifndef yyset_debug_ALREADY_DEFINED -#undef yyset_debug -#endif -#ifndef yyget_extra_ALREADY_DEFINED -#undef yyget_extra -#endif -#ifndef yyset_extra_ALREADY_DEFINED -#undef yyset_extra -#endif -#ifndef yyget_in_ALREADY_DEFINED -#undef yyget_in -#endif -#ifndef yyset_in_ALREADY_DEFINED -#undef yyset_in -#endif -#ifndef yyget_out_ALREADY_DEFINED -#undef yyget_out -#endif -#ifndef yyset_out_ALREADY_DEFINED -#undef yyset_out -#endif -#ifndef yyget_leng_ALREADY_DEFINED -#undef yyget_leng -#endif -#ifndef yyget_text_ALREADY_DEFINED -#undef yyget_text -#endif -#ifndef yyget_lineno_ALREADY_DEFINED -#undef yyget_lineno -#endif -#ifndef yyset_lineno_ALREADY_DEFINED -#undef yyset_lineno -#endif -#ifndef yyget_column_ALREADY_DEFINED -#undef yyget_column -#endif -#ifndef yyset_column_ALREADY_DEFINED -#undef yyset_column -#endif -#ifndef yywrap_ALREADY_DEFINED -#undef yywrap -#endif -#ifndef yyget_lval_ALREADY_DEFINED -#undef yyget_lval -#endif -#ifndef yyset_lval_ALREADY_DEFINED -#undef yyset_lval -#endif -#ifndef yyget_lloc_ALREADY_DEFINED -#undef yyget_lloc -#endif -#ifndef yyset_lloc_ALREADY_DEFINED -#undef yyset_lloc -#endif -#ifndef yyalloc_ALREADY_DEFINED -#undef yyalloc -#endif -#ifndef yyrealloc_ALREADY_DEFINED -#undef yyrealloc -#endif -#ifndef yyfree_ALREADY_DEFINED -#undef yyfree -#endif -#ifndef yytext_ALREADY_DEFINED -#undef yytext -#endif -#ifndef yyleng_ALREADY_DEFINED -#undef yyleng -#endif -#ifndef yyin_ALREADY_DEFINED -#undef yyin -#endif -#ifndef yyout_ALREADY_DEFINED -#undef yyout -#endif -#ifndef yy_flex_debug_ALREADY_DEFINED -#undef yy_flex_debug -#endif -#ifndef yylineno_ALREADY_DEFINED -#undef yylineno -#endif -#ifndef yytables_fload_ALREADY_DEFINED -#undef yytables_fload -#endif -#ifndef yytables_destroy_ALREADY_DEFINED -#undef yytables_destroy -#endif -#ifndef yyTABLES_NAME_ALREADY_DEFINED -#undef yyTABLES_NAME -#endif - -#line 128 "..//lexer.l" - - -#line 476 "lexer.h" -#undef yyIN_HEADER -#endif /* yyHEADER_H */ diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh b/source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh deleted file mode 100644 index be150130f8..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/Windows/location.hh +++ /dev/null @@ -1,306 +0,0 @@ -// A Bison parser, made by GNU Bison 3.8.2. - -// Locations for Bison parsers in C++ - -// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. - -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with this program. If not, see . - -// As a special exception, you may create a larger work that contains -// part or all of the Bison parser skeleton and distribute that work -// under terms of your choice, so long as that work isn't itself a -// parser generator using the skeleton or a modified version thereof -// as a parser skeleton. Alternatively, if you modify or redistribute -// the parser skeleton itself, you may (at your option) remove this -// special exception, which will cause the skeleton and the resulting -// Bison output files to be licensed under the GNU General Public -// License without this special exception. - -// This special exception was added by the Free Software Foundation in -// version 2.2 of Bison. - -/** - ** \file location.hh - ** Define the adios2::detail::location class. - */ - -#ifndef YY_YY_LOCATION_HH_INCLUDED -# define YY_YY_LOCATION_HH_INCLUDED - -# include -# include - -# ifndef YY_NULLPTR -# if defined __cplusplus -# if 201103L <= __cplusplus -# define YY_NULLPTR nullptr -# else -# define YY_NULLPTR 0 -# endif -# else -# define YY_NULLPTR ((void*)0) -# endif -# endif - -#line 6 "parser.y" -namespace adios2 { namespace detail { -#line 59 "location.hh" - - /// A point in a source file. - class position - { - public: - /// Type for file name. - typedef const std::string filename_type; - /// Type for line and column numbers. - typedef int counter_type; - - /// Construct a position. - explicit position (filename_type* f = YY_NULLPTR, - counter_type l = 1, - counter_type c = 1) - : filename (f) - , line (l) - , column (c) - {} - - - /// Initialization. - void initialize (filename_type* fn = YY_NULLPTR, - counter_type l = 1, - counter_type c = 1) - { - filename = fn; - line = l; - column = c; - } - - /** \name Line and Column related manipulators - ** \{ */ - /// (line related) Advance to the COUNT next lines. - void lines (counter_type count = 1) - { - if (count) - { - column = 1; - line = add_ (line, count, 1); - } - } - - /// (column related) Advance to the COUNT next columns. - void columns (counter_type count = 1) - { - column = add_ (column, count, 1); - } - /** \} */ - - /// File name to which this position refers. - filename_type* filename; - /// Current line number. - counter_type line; - /// Current column number. - counter_type column; - - private: - /// Compute max (min, lhs+rhs). - static counter_type add_ (counter_type lhs, counter_type rhs, counter_type min) - { - return lhs + rhs < min ? min : lhs + rhs; - } - }; - - /// Add \a width columns, in place. - inline position& - operator+= (position& res, position::counter_type width) - { - res.columns (width); - return res; - } - - /// Add \a width columns. - inline position - operator+ (position res, position::counter_type width) - { - return res += width; - } - - /// Subtract \a width columns, in place. - inline position& - operator-= (position& res, position::counter_type width) - { - return res += -width; - } - - /// Subtract \a width columns. - inline position - operator- (position res, position::counter_type width) - { - return res -= width; - } - - /** \brief Intercept output stream redirection. - ** \param ostr the destination output stream - ** \param pos a reference to the position to redirect - */ - template - std::basic_ostream& - operator<< (std::basic_ostream& ostr, const position& pos) - { - if (pos.filename) - ostr << *pos.filename << ':'; - return ostr << pos.line << '.' << pos.column; - } - - /// Two points in a source file. - class location - { - public: - /// Type for file name. - typedef position::filename_type filename_type; - /// Type for line and column numbers. - typedef position::counter_type counter_type; - - /// Construct a location from \a b to \a e. - location (const position& b, const position& e) - : begin (b) - , end (e) - {} - - /// Construct a 0-width location in \a p. - explicit location (const position& p = position ()) - : begin (p) - , end (p) - {} - - /// Construct a 0-width location in \a f, \a l, \a c. - explicit location (filename_type* f, - counter_type l = 1, - counter_type c = 1) - : begin (f, l, c) - , end (f, l, c) - {} - - - /// Initialization. - void initialize (filename_type* f = YY_NULLPTR, - counter_type l = 1, - counter_type c = 1) - { - begin.initialize (f, l, c); - end = begin; - } - - /** \name Line and Column related manipulators - ** \{ */ - public: - /// Reset initial location to final location. - void step () - { - begin = end; - } - - /// Extend the current location to the COUNT next columns. - void columns (counter_type count = 1) - { - end += count; - } - - /// Extend the current location to the COUNT next lines. - void lines (counter_type count = 1) - { - end.lines (count); - } - /** \} */ - - - public: - /// Beginning of the located region. - position begin; - /// End of the located region. - position end; - }; - - /// Join two locations, in place. - inline location& - operator+= (location& res, const location& end) - { - res.end = end.end; - return res; - } - - /// Join two locations. - inline location - operator+ (location res, const location& end) - { - return res += end; - } - - /// Add \a width columns to the end position, in place. - inline location& - operator+= (location& res, location::counter_type width) - { - res.columns (width); - return res; - } - - /// Add \a width columns to the end position. - inline location - operator+ (location res, location::counter_type width) - { - return res += width; - } - - /// Subtract \a width columns to the end position, in place. - inline location& - operator-= (location& res, location::counter_type width) - { - return res += -width; - } - - /// Subtract \a width columns to the end position. - inline location - operator- (location res, location::counter_type width) - { - return res -= width; - } - - /** \brief Intercept output stream redirection. - ** \param ostr the destination output stream - ** \param loc a reference to the location to redirect - ** - ** Avoid duplicate information. - */ - template - std::basic_ostream& - operator<< (std::basic_ostream& ostr, const location& loc) - { - location::counter_type end_col - = 0 < loc.end.column ? loc.end.column - 1 : 0; - ostr << loc.begin; - if (loc.end.filename - && (!loc.begin.filename - || *loc.begin.filename != *loc.end.filename)) - ostr << '-' << loc.end.filename << ':' << loc.end.line << '.' << end_col; - else if (loc.begin.line < loc.end.line) - ostr << '-' << loc.end.line << '.' << end_col; - else if (loc.begin.column < end_col) - ostr << '-' << end_col; - return ostr; - } - -#line 6 "parser.y" -} } // adios2::detail -#line 305 "location.hh" - -#endif // !YY_YY_LOCATION_HH_INCLUDED diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp deleted file mode 100644 index 9a53a89e3b..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.cpp +++ /dev/null @@ -1,1414 +0,0 @@ -// A Bison parser, made by GNU Bison 3.8.2. - -// Skeleton implementation for Bison LALR(1) parsers in C++ - -// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. - -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with this program. If not, see . - -// As a special exception, you may create a larger work that contains -// part or all of the Bison parser skeleton and distribute that work -// under terms of your choice, so long as that work isn't itself a -// parser generator using the skeleton or a modified version thereof -// as a parser skeleton. Alternatively, if you modify or redistribute -// the parser skeleton itself, you may (at your option) remove this -// special exception, which will cause the skeleton and the resulting -// Bison output files to be licensed under the GNU General Public -// License without this special exception. - -// This special exception was added by the Free Software Foundation in -// version 2.2 of Bison. - -// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, -// especially those whose name start with YY_ or yy_. They are -// private implementation details that can be changed or removed. - - - - - -#include "parser.h" - - -// Unqualified %code blocks. -#line 33 "parser.y" - -#include "ASTDriver.h" -#include "ASTNode.h" - -#line 51 "parser.cpp" - - -#ifndef YY_ -# if defined YYENABLE_NLS && YYENABLE_NLS -# if ENABLE_NLS -# include // FIXME: INFRINGES ON USER NAME SPACE. -# define YY_(msgid) dgettext ("bison-runtime", msgid) -# endif -# endif -# ifndef YY_ -# define YY_(msgid) msgid -# endif -#endif - - -// Whether we are compiled with exception support. -#ifndef YY_EXCEPTIONS -# if defined __GNUC__ && !defined __EXCEPTIONS -# define YY_EXCEPTIONS 0 -# else -# define YY_EXCEPTIONS 1 -# endif -#endif - -#define YYRHSLOC(Rhs, K) ((Rhs)[K].location) -/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. - If N is 0, then set CURRENT to the empty location which ends - the previous symbol: RHS[0] (always defined). */ - -# ifndef YYLLOC_DEFAULT -# define YYLLOC_DEFAULT(Current, Rhs, N) \ - do \ - if (N) \ - { \ - (Current).begin = YYRHSLOC (Rhs, 1).begin; \ - (Current).end = YYRHSLOC (Rhs, N).end; \ - } \ - else \ - { \ - (Current).begin = (Current).end = YYRHSLOC (Rhs, 0).end; \ - } \ - while (false) -# endif - - -// Enable debugging if requested. -#if YYDEBUG - -// A pseudo ostream that takes yydebug_ into account. -# define YYCDEBUG if (yydebug_) (*yycdebug_) - -# define YY_SYMBOL_PRINT(Title, Symbol) \ - do { \ - if (yydebug_) \ - { \ - *yycdebug_ << Title << ' '; \ - yy_print_ (*yycdebug_, Symbol); \ - *yycdebug_ << '\n'; \ - } \ - } while (false) - -# define YY_REDUCE_PRINT(Rule) \ - do { \ - if (yydebug_) \ - yy_reduce_print_ (Rule); \ - } while (false) - -# define YY_STACK_PRINT() \ - do { \ - if (yydebug_) \ - yy_stack_print_ (); \ - } while (false) - -#else // !YYDEBUG - -# define YYCDEBUG if (false) std::cerr -# define YY_SYMBOL_PRINT(Title, Symbol) YY_USE (Symbol) -# define YY_REDUCE_PRINT(Rule) static_cast (0) -# define YY_STACK_PRINT() static_cast (0) - -#endif // !YYDEBUG - -#define yyerrok (yyerrstatus_ = 0) -#define yyclearin (yyla.clear ()) - -#define YYACCEPT goto yyacceptlab -#define YYABORT goto yyabortlab -#define YYERROR goto yyerrorlab -#define YYRECOVERING() (!!yyerrstatus_) - -#line 6 "parser.y" -namespace adios2 { namespace detail { -#line 144 "parser.cpp" - - /// Build a parser object. - parser::parser (ASTDriver& drv_yyarg) -#if YYDEBUG - : yydebug_ (false), - yycdebug_ (&std::cerr), -#else - : -#endif - yy_lac_established_ (false), - drv (drv_yyarg) - {} - - parser::~parser () - {} - - parser::syntax_error::~syntax_error () YY_NOEXCEPT YY_NOTHROW - {} - - /*---------. - | symbol. | - `---------*/ - - - - // by_state. - parser::by_state::by_state () YY_NOEXCEPT - : state (empty_state) - {} - - parser::by_state::by_state (const by_state& that) YY_NOEXCEPT - : state (that.state) - {} - - void - parser::by_state::clear () YY_NOEXCEPT - { - state = empty_state; - } - - void - parser::by_state::move (by_state& that) - { - state = that.state; - that.clear (); - } - - parser::by_state::by_state (state_type s) YY_NOEXCEPT - : state (s) - {} - - parser::symbol_kind_type - parser::by_state::kind () const YY_NOEXCEPT - { - if (state == empty_state) - return symbol_kind::S_YYEMPTY; - else - return YY_CAST (symbol_kind_type, yystos_[+state]); - } - - parser::stack_symbol_type::stack_symbol_type () - {} - - parser::stack_symbol_type::stack_symbol_type (YY_RVREF (stack_symbol_type) that) - : super_type (YY_MOVE (that.state), YY_MOVE (that.location)) - { - switch (that.kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.YY_MOVE_OR_COPY< int > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.YY_MOVE_OR_COPY< std::string > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_index: // index - value.YY_MOVE_OR_COPY< std::tuple > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_indices_list: // indices_list - value.YY_MOVE_OR_COPY< std::vector> > (YY_MOVE (that.value)); - break; - - default: - break; - } - -#if 201103L <= YY_CPLUSPLUS - // that is emptied. - that.state = empty_state; -#endif - } - - parser::stack_symbol_type::stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) that) - : super_type (s, YY_MOVE (that.location)) - { - switch (that.kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.move< int > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.move< std::string > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_index: // index - value.move< std::tuple > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_indices_list: // indices_list - value.move< std::vector> > (YY_MOVE (that.value)); - break; - - default: - break; - } - - // that is emptied. - that.kind_ = symbol_kind::S_YYEMPTY; - } - -#if YY_CPLUSPLUS < 201103L - parser::stack_symbol_type& - parser::stack_symbol_type::operator= (const stack_symbol_type& that) - { - state = that.state; - switch (that.kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.copy< int > (that.value); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.copy< std::string > (that.value); - break; - - case symbol_kind::S_index: // index - value.copy< std::tuple > (that.value); - break; - - case symbol_kind::S_indices_list: // indices_list - value.copy< std::vector> > (that.value); - break; - - default: - break; - } - - location = that.location; - return *this; - } - - parser::stack_symbol_type& - parser::stack_symbol_type::operator= (stack_symbol_type& that) - { - state = that.state; - switch (that.kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.move< int > (that.value); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.move< std::string > (that.value); - break; - - case symbol_kind::S_index: // index - value.move< std::tuple > (that.value); - break; - - case symbol_kind::S_indices_list: // indices_list - value.move< std::vector> > (that.value); - break; - - default: - break; - } - - location = that.location; - // that is emptied. - that.state = empty_state; - return *this; - } -#endif - - template - void - parser::yy_destroy_ (const char* yymsg, basic_symbol& yysym) const - { - if (yymsg) - YY_SYMBOL_PRINT (yymsg, yysym); - } - -#if YYDEBUG - template - void - parser::yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const - { - std::ostream& yyoutput = yyo; - YY_USE (yyoutput); - if (yysym.empty ()) - yyo << "empty symbol"; - else - { - symbol_kind_type yykind = yysym.kind (); - yyo << (yykind < YYNTOKENS ? "token" : "nterm") - << ' ' << yysym.name () << " (" - << yysym.location << ": "; - YY_USE (yykind); - yyo << ')'; - } - } -#endif - - void - parser::yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym) - { - if (m) - YY_SYMBOL_PRINT (m, sym); - yystack_.push (YY_MOVE (sym)); - } - - void - parser::yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym) - { -#if 201103L <= YY_CPLUSPLUS - yypush_ (m, stack_symbol_type (s, std::move (sym))); -#else - stack_symbol_type ss (s, sym); - yypush_ (m, ss); -#endif - } - - void - parser::yypop_ (int n) YY_NOEXCEPT - { - yystack_.pop (n); - } - -#if YYDEBUG - std::ostream& - parser::debug_stream () const - { - return *yycdebug_; - } - - void - parser::set_debug_stream (std::ostream& o) - { - yycdebug_ = &o; - } - - - parser::debug_level_type - parser::debug_level () const - { - return yydebug_; - } - - void - parser::set_debug_level (debug_level_type l) - { - yydebug_ = l; - } -#endif // YYDEBUG - - parser::state_type - parser::yy_lr_goto_state_ (state_type yystate, int yysym) - { - int yyr = yypgoto_[yysym - YYNTOKENS] + yystate; - if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate) - return yytable_[yyr]; - else - return yydefgoto_[yysym - YYNTOKENS]; - } - - bool - parser::yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT - { - return yyvalue == yypact_ninf_; - } - - bool - parser::yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT - { - return yyvalue == yytable_ninf_; - } - - int - parser::operator() () - { - return parse (); - } - - int - parser::parse () - { - int yyn; - /// Length of the RHS of the rule being reduced. - int yylen = 0; - - // Error handling. - int yynerrs_ = 0; - int yyerrstatus_ = 0; - - /// The lookahead symbol. - symbol_type yyla; - - /// The locations where the error started and ended. - stack_symbol_type yyerror_range[3]; - - /// The return value of parse (). - int yyresult; - - // Discard the LAC context in case there still is one left from a - // previous invocation. - yy_lac_discard_ ("init"); - -#if YY_EXCEPTIONS - try -#endif // YY_EXCEPTIONS - { - YYCDEBUG << "Starting parse\n"; - - - /* Initialize the stack. The initial state will be set in - yynewstate, since the latter expects the semantical and the - location values to have been already stored, initialize these - stacks with a primary value. */ - yystack_.clear (); - yypush_ (YY_NULLPTR, 0, YY_MOVE (yyla)); - - /*-----------------------------------------------. - | yynewstate -- push a new symbol on the stack. | - `-----------------------------------------------*/ - yynewstate: - YYCDEBUG << "Entering state " << int (yystack_[0].state) << '\n'; - YY_STACK_PRINT (); - - // Accept? - if (yystack_[0].state == yyfinal_) - YYACCEPT; - - goto yybackup; - - - /*-----------. - | yybackup. | - `-----------*/ - yybackup: - // Try to take a decision without lookahead. - yyn = yypact_[+yystack_[0].state]; - if (yy_pact_value_is_default_ (yyn)) - goto yydefault; - - // Read a lookahead token. - if (yyla.empty ()) - { - YYCDEBUG << "Reading a token\n"; -#if YY_EXCEPTIONS - try -#endif // YY_EXCEPTIONS - { - symbol_type yylookahead (yylex (drv)); - yyla.move (yylookahead); - } -#if YY_EXCEPTIONS - catch (const syntax_error& yyexc) - { - YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; - error (yyexc); - goto yyerrlab1; - } -#endif // YY_EXCEPTIONS - } - YY_SYMBOL_PRINT ("Next token is", yyla); - - if (yyla.kind () == symbol_kind::S_YYerror) - { - // The scanner already issued an error message, process directly - // to error recovery. But do not keep the error token as - // lookahead, it is too special and may lead us to an endless - // loop in error recovery. */ - yyla.kind_ = symbol_kind::S_YYUNDEF; - goto yyerrlab1; - } - - /* If the proper action on seeing token YYLA.TYPE is to reduce or - to detect an error, take that action. */ - yyn += yyla.kind (); - if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yyla.kind ()) - { - if (!yy_lac_establish_ (yyla.kind ())) - goto yyerrlab; - goto yydefault; - } - - // Reduce or error. - yyn = yytable_[yyn]; - if (yyn <= 0) - { - if (yy_table_value_is_error_ (yyn)) - goto yyerrlab; - if (!yy_lac_establish_ (yyla.kind ())) - goto yyerrlab; - - yyn = -yyn; - goto yyreduce; - } - - // Count tokens shifted since error; after three, turn off error status. - if (yyerrstatus_) - --yyerrstatus_; - - // Shift the lookahead token. - yypush_ ("Shifting", state_type (yyn), YY_MOVE (yyla)); - yy_lac_discard_ ("shift"); - goto yynewstate; - - - /*-----------------------------------------------------------. - | yydefault -- do the default action for the current state. | - `-----------------------------------------------------------*/ - yydefault: - yyn = yydefact_[+yystack_[0].state]; - if (yyn == 0) - goto yyerrlab; - goto yyreduce; - - - /*-----------------------------. - | yyreduce -- do a reduction. | - `-----------------------------*/ - yyreduce: - yylen = yyr2_[yyn]; - { - stack_symbol_type yylhs; - yylhs.state = yy_lr_goto_state_ (yystack_[yylen].state, yyr1_[yyn]); - /* Variants are always initialized to an empty instance of the - correct type. The default '$$ = $1' action is NOT applied - when using variants. */ - switch (yyr1_[yyn]) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - yylhs.value.emplace< int > (); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - yylhs.value.emplace< std::string > (); - break; - - case symbol_kind::S_index: // index - yylhs.value.emplace< std::tuple > (); - break; - - case symbol_kind::S_indices_list: // indices_list - yylhs.value.emplace< std::vector> > (); - break; - - default: - break; - } - - - // Default location. - { - stack_type::slice range (yystack_, yylen); - YYLLOC_DEFAULT (yylhs.location, range, yylen); - yyerror_range[1].location = yylhs.location; - } - - // Perform the reduction. - YY_REDUCE_PRINT (yyn); -#if YY_EXCEPTIONS - try -#endif // YY_EXCEPTIONS - { - switch (yyn) - { - case 2: // lines: assignment "\n" lines -#line 62 "parser.y" - {} -#line 644 "parser.cpp" - break; - - case 3: // lines: exp -#line 63 "parser.y" - {} -#line 650 "parser.cpp" - break; - - case 4: // assignment: "identifier" "=" VARNAME -#line 67 "parser.y" - { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } -#line 656 "parser.cpp" - break; - - case 5: // assignment: "identifier" "=" "identifier" -#line 68 "parser.y" - { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } -#line 662 "parser.cpp" - break; - - case 6: // assignment: "identifier" "=" VARNAME "[" indices_list "]" -#line 69 "parser.y" - { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } -#line 668 "parser.cpp" - break; - - case 7: // assignment: "identifier" "=" "identifier" "[" indices_list "]" -#line 70 "parser.y" - { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } -#line 674 "parser.cpp" - break; - - case 8: // exp: "number" -#line 74 "parser.y" - { } -#line 680 "parser.cpp" - break; - - case 9: // exp: exp OPERATOR exp -#line 75 "parser.y" - { drv.createNode(yystack_[1].value.as < std::string > (), 2); } -#line 686 "parser.cpp" - break; - - case 10: // exp: "(" exp ")" -#line 76 "parser.y" - { } -#line 692 "parser.cpp" - break; - - case 11: // exp: "identifier" "(" list ")" -#line 77 "parser.y" - { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } -#line 698 "parser.cpp" - break; - - case 12: // exp: "identifier" "[" indices_list "]" -#line 78 "parser.y" - { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } -#line 704 "parser.cpp" - break; - - case 13: // exp: "identifier" -#line 79 "parser.y" - { drv.createNode(yystack_[0].value.as < std::string > ()); } -#line 710 "parser.cpp" - break; - - case 14: // indices_list: %empty -#line 84 "parser.y" - { yylhs.value.as < std::vector> > () = {}; } -#line 716 "parser.cpp" - break; - - case 15: // indices_list: indices_list "," index -#line 85 "parser.y" - { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } -#line 722 "parser.cpp" - break; - - case 16: // indices_list: index -#line 86 "parser.y" - { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } -#line 728 "parser.cpp" - break; - - case 17: // index: %empty -#line 90 "parser.y" - { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } -#line 734 "parser.cpp" - break; - - case 18: // index: "number" ":" "number" ":" "number" -#line 91 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } -#line 740 "parser.cpp" - break; - - case 19: // index: ":" "number" ":" "number" -#line 92 "parser.y" - { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } -#line 746 "parser.cpp" - break; - - case 20: // index: "number" ":" ":" "number" -#line 93 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } -#line 752 "parser.cpp" - break; - - case 21: // index: "number" ":" "number" ":" -#line 94 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } -#line 758 "parser.cpp" - break; - - case 22: // index: "number" ":" "number" -#line 95 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } -#line 764 "parser.cpp" - break; - - case 23: // index: ":" ":" "number" -#line 96 "parser.y" - { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } -#line 770 "parser.cpp" - break; - - case 24: // index: ":" "number" ":" -#line 97 "parser.y" - { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } -#line 776 "parser.cpp" - break; - - case 25: // index: ":" "number" -#line 98 "parser.y" - { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } -#line 782 "parser.cpp" - break; - - case 26: // index: "number" ":" ":" -#line 99 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } -#line 788 "parser.cpp" - break; - - case 27: // index: "number" ":" -#line 100 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } -#line 794 "parser.cpp" - break; - - case 28: // index: "number" -#line 101 "parser.y" - { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } -#line 800 "parser.cpp" - break; - - case 29: // list: %empty -#line 105 "parser.y" - { yylhs.value.as < int > () = 0; } -#line 806 "parser.cpp" - break; - - case 30: // list: exp "," list -#line 106 "parser.y" - { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } -#line 812 "parser.cpp" - break; - - case 31: // list: exp -#line 107 "parser.y" - { yylhs.value.as < int > () = 1; } -#line 818 "parser.cpp" - break; - - -#line 822 "parser.cpp" - - default: - break; - } - } -#if YY_EXCEPTIONS - catch (const syntax_error& yyexc) - { - YYCDEBUG << "Caught exception: " << yyexc.what() << '\n'; - error (yyexc); - YYERROR; - } -#endif // YY_EXCEPTIONS - YY_SYMBOL_PRINT ("-> $$ =", yylhs); - yypop_ (yylen); - yylen = 0; - - // Shift the result of the reduction. - yypush_ (YY_NULLPTR, YY_MOVE (yylhs)); - } - goto yynewstate; - - - /*--------------------------------------. - | yyerrlab -- here on detecting error. | - `--------------------------------------*/ - yyerrlab: - // If not already recovering from an error, report this error. - if (!yyerrstatus_) - { - ++yynerrs_; - context yyctx (*this, yyla); - std::string msg = yysyntax_error_ (yyctx); - error (yyla.location, YY_MOVE (msg)); - } - - - yyerror_range[1].location = yyla.location; - if (yyerrstatus_ == 3) - { - /* If just tried and failed to reuse lookahead token after an - error, discard it. */ - - // Return failure if at end of input. - if (yyla.kind () == symbol_kind::S_YYEOF) - YYABORT; - else if (!yyla.empty ()) - { - yy_destroy_ ("Error: discarding", yyla); - yyla.clear (); - } - } - - // Else will try to reuse lookahead token after shifting the error token. - goto yyerrlab1; - - - /*---------------------------------------------------. - | yyerrorlab -- error raised explicitly by YYERROR. | - `---------------------------------------------------*/ - yyerrorlab: - /* Pacify compilers when the user code never invokes YYERROR and - the label yyerrorlab therefore never appears in user code. */ - if (false) - YYERROR; - - /* Do not reclaim the symbols of the rule whose action triggered - this YYERROR. */ - yypop_ (yylen); - yylen = 0; - YY_STACK_PRINT (); - goto yyerrlab1; - - - /*-------------------------------------------------------------. - | yyerrlab1 -- common code for both syntax error and YYERROR. | - `-------------------------------------------------------------*/ - yyerrlab1: - yyerrstatus_ = 3; // Each real token shifted decrements this. - // Pop stack until we find a state that shifts the error token. - for (;;) - { - yyn = yypact_[+yystack_[0].state]; - if (!yy_pact_value_is_default_ (yyn)) - { - yyn += symbol_kind::S_YYerror; - if (0 <= yyn && yyn <= yylast_ - && yycheck_[yyn] == symbol_kind::S_YYerror) - { - yyn = yytable_[yyn]; - if (0 < yyn) - break; - } - } - - // Pop the current state because it cannot handle the error token. - if (yystack_.size () == 1) - YYABORT; - - yyerror_range[1].location = yystack_[0].location; - yy_destroy_ ("Error: popping", yystack_[0]); - yypop_ (); - YY_STACK_PRINT (); - } - { - stack_symbol_type error_token; - - yyerror_range[2].location = yyla.location; - YYLLOC_DEFAULT (error_token.location, yyerror_range, 2); - - // Shift the error token. - yy_lac_discard_ ("error recovery"); - error_token.state = state_type (yyn); - yypush_ ("Shifting", YY_MOVE (error_token)); - } - goto yynewstate; - - - /*-------------------------------------. - | yyacceptlab -- YYACCEPT comes here. | - `-------------------------------------*/ - yyacceptlab: - yyresult = 0; - goto yyreturn; - - - /*-----------------------------------. - | yyabortlab -- YYABORT comes here. | - `-----------------------------------*/ - yyabortlab: - yyresult = 1; - goto yyreturn; - - - /*-----------------------------------------------------. - | yyreturn -- parsing is finished, return the result. | - `-----------------------------------------------------*/ - yyreturn: - if (!yyla.empty ()) - yy_destroy_ ("Cleanup: discarding lookahead", yyla); - - /* Do not reclaim the symbols of the rule whose action triggered - this YYABORT or YYACCEPT. */ - yypop_ (yylen); - YY_STACK_PRINT (); - while (1 < yystack_.size ()) - { - yy_destroy_ ("Cleanup: popping", yystack_[0]); - yypop_ (); - } - - return yyresult; - } -#if YY_EXCEPTIONS - catch (...) - { - YYCDEBUG << "Exception caught: cleaning lookahead and stack\n"; - // Do not try to display the values of the reclaimed symbols, - // as their printers might throw an exception. - if (!yyla.empty ()) - yy_destroy_ (YY_NULLPTR, yyla); - - while (1 < yystack_.size ()) - { - yy_destroy_ (YY_NULLPTR, yystack_[0]); - yypop_ (); - } - throw; - } -#endif // YY_EXCEPTIONS - } - - void - parser::error (const syntax_error& yyexc) - { - error (yyexc.location, yyexc.what ()); - } - - const char * - parser::symbol_name (symbol_kind_type yysymbol) - { - static const char *const yy_sname[] = - { - "end of file", "error", "invalid token", "=", ",", ":", "(", ")", "[", - "]", "\n", "OPERATOR", "identifier", "VARNAME", "number", "$accept", - "lines", "assignment", "exp", "indices_list", "index", "list", YY_NULLPTR - }; - return yy_sname[yysymbol]; - } - - - - // parser::context. - parser::context::context (const parser& yyparser, const symbol_type& yyla) - : yyparser_ (yyparser) - , yyla_ (yyla) - {} - - int - parser::context::expected_tokens (symbol_kind_type yyarg[], int yyargn) const - { - // Actual number of expected tokens - int yycount = 0; - -#if YYDEBUG - // Execute LAC once. We don't care if it is successful, we - // only do it for the sake of debugging output. - if (!yyparser_.yy_lac_established_) - yyparser_.yy_lac_check_ (yyla_.kind ()); -#endif - - for (int yyx = 0; yyx < YYNTOKENS; ++yyx) - { - symbol_kind_type yysym = YY_CAST (symbol_kind_type, yyx); - if (yysym != symbol_kind::S_YYerror - && yysym != symbol_kind::S_YYUNDEF - && yyparser_.yy_lac_check_ (yysym)) - { - if (!yyarg) - ++yycount; - else if (yycount == yyargn) - return 0; - else - yyarg[yycount++] = yysym; - } - } - if (yyarg && yycount == 0 && 0 < yyargn) - yyarg[0] = symbol_kind::S_YYEMPTY; - return yycount; - } - - - - - bool - parser::yy_lac_check_ (symbol_kind_type yytoken) const - { - // Logically, the yylac_stack's lifetime is confined to this function. - // Clear it, to get rid of potential left-overs from previous call. - yylac_stack_.clear (); - // Reduce until we encounter a shift and thereby accept the token. -#if YYDEBUG - YYCDEBUG << "LAC: checking lookahead " << symbol_name (yytoken) << ':'; -#endif - std::ptrdiff_t lac_top = 0; - while (true) - { - state_type top_state = (yylac_stack_.empty () - ? yystack_[lac_top].state - : yylac_stack_.back ()); - int yyrule = yypact_[+top_state]; - if (yy_pact_value_is_default_ (yyrule) - || (yyrule += yytoken) < 0 || yylast_ < yyrule - || yycheck_[yyrule] != yytoken) - { - // Use the default action. - yyrule = yydefact_[+top_state]; - if (yyrule == 0) - { - YYCDEBUG << " Err\n"; - return false; - } - } - else - { - // Use the action from yytable. - yyrule = yytable_[yyrule]; - if (yy_table_value_is_error_ (yyrule)) - { - YYCDEBUG << " Err\n"; - return false; - } - if (0 < yyrule) - { - YYCDEBUG << " S" << yyrule << '\n'; - return true; - } - yyrule = -yyrule; - } - // By now we know we have to simulate a reduce. - YYCDEBUG << " R" << yyrule - 1; - // Pop the corresponding number of values from the stack. - { - std::ptrdiff_t yylen = yyr2_[yyrule]; - // First pop from the LAC stack as many tokens as possible. - std::ptrdiff_t lac_size = std::ptrdiff_t (yylac_stack_.size ()); - if (yylen < lac_size) - { - yylac_stack_.resize (std::size_t (lac_size - yylen)); - yylen = 0; - } - else if (lac_size) - { - yylac_stack_.clear (); - yylen -= lac_size; - } - // Only afterwards look at the main stack. - // We simulate popping elements by incrementing lac_top. - lac_top += yylen; - } - // Keep top_state in sync with the updated stack. - top_state = (yylac_stack_.empty () - ? yystack_[lac_top].state - : yylac_stack_.back ()); - // Push the resulting state of the reduction. - state_type state = yy_lr_goto_state_ (top_state, yyr1_[yyrule]); - YYCDEBUG << " G" << int (state); - yylac_stack_.push_back (state); - } - } - - // Establish the initial context if no initial context currently exists. - bool - parser::yy_lac_establish_ (symbol_kind_type yytoken) - { - /* Establish the initial context for the current lookahead if no initial - context is currently established. - - We define a context as a snapshot of the parser stacks. We define - the initial context for a lookahead as the context in which the - parser initially examines that lookahead in order to select a - syntactic action. Thus, if the lookahead eventually proves - syntactically unacceptable (possibly in a later context reached via a - series of reductions), the initial context can be used to determine - the exact set of tokens that would be syntactically acceptable in the - lookahead's place. Moreover, it is the context after which any - further semantic actions would be erroneous because they would be - determined by a syntactically unacceptable token. - - yy_lac_establish_ should be invoked when a reduction is about to be - performed in an inconsistent state (which, for the purposes of LAC, - includes consistent states that don't know they're consistent because - their default reductions have been disabled). - - For parse.lac=full, the implementation of yy_lac_establish_ is as - follows. If no initial context is currently established for the - current lookahead, then check if that lookahead can eventually be - shifted if syntactic actions continue from the current context. */ - if (yy_lac_established_) - return true; - else - { -#if YYDEBUG - YYCDEBUG << "LAC: initial context established for " - << symbol_name (yytoken) << '\n'; -#endif - yy_lac_established_ = true; - return yy_lac_check_ (yytoken); - } - } - - // Discard any previous initial lookahead context. - void - parser::yy_lac_discard_ (const char* event) - { - /* Discard any previous initial lookahead context because of Event, - which may be a lookahead change or an invalidation of the currently - established initial context for the current lookahead. - - The most common example of a lookahead change is a shift. An example - of both cases is syntax error recovery. That is, a syntax error - occurs when the lookahead is syntactically erroneous for the - currently established initial context, so error recovery manipulates - the parser stacks to try to find a new initial context in which the - current lookahead is syntactically acceptable. If it fails to find - such a context, it discards the lookahead. */ - if (yy_lac_established_) - { - YYCDEBUG << "LAC: initial context discarded due to " - << event << '\n'; - yy_lac_established_ = false; - } - } - - - int - parser::yy_syntax_error_arguments_ (const context& yyctx, - symbol_kind_type yyarg[], int yyargn) const - { - /* There are many possibilities here to consider: - - If this state is a consistent state with a default action, then - the only way this function was invoked is if the default action - is an error action. In that case, don't check for expected - tokens because there are none. - - The only way there can be no lookahead present (in yyla) is - if this state is a consistent state with a default action. - Thus, detecting the absence of a lookahead is sufficient to - determine that there is no unexpected or expected token to - report. In that case, just report a simple "syntax error". - - Don't assume there isn't a lookahead just because this state is - a consistent state with a default action. There might have - been a previous inconsistent state, consistent state with a - non-default action, or user semantic action that manipulated - yyla. (However, yyla is currently not documented for users.) - In the first two cases, it might appear that the current syntax - error should have been detected in the previous state when - yy_lac_check was invoked. However, at that time, there might - have been a different syntax error that discarded a different - initial context during error recovery, leaving behind the - current lookahead. - */ - - if (!yyctx.lookahead ().empty ()) - { - if (yyarg) - yyarg[0] = yyctx.token (); - int yyn = yyctx.expected_tokens (yyarg ? yyarg + 1 : yyarg, yyargn - 1); - return yyn + 1; - } - return 0; - } - - // Generate an error message. - std::string - parser::yysyntax_error_ (const context& yyctx) const - { - // Its maximum. - enum { YYARGS_MAX = 5 }; - // Arguments of yyformat. - symbol_kind_type yyarg[YYARGS_MAX]; - int yycount = yy_syntax_error_arguments_ (yyctx, yyarg, YYARGS_MAX); - - char const* yyformat = YY_NULLPTR; - switch (yycount) - { -#define YYCASE_(N, S) \ - case N: \ - yyformat = S; \ - break - default: // Avoid compiler warnings. - YYCASE_ (0, YY_("syntax error")); - YYCASE_ (1, YY_("syntax error, unexpected %s")); - YYCASE_ (2, YY_("syntax error, unexpected %s, expecting %s")); - YYCASE_ (3, YY_("syntax error, unexpected %s, expecting %s or %s")); - YYCASE_ (4, YY_("syntax error, unexpected %s, expecting %s or %s or %s")); - YYCASE_ (5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")); -#undef YYCASE_ - } - - std::string yyres; - // Argument number. - std::ptrdiff_t yyi = 0; - for (char const* yyp = yyformat; *yyp; ++yyp) - if (yyp[0] == '%' && yyp[1] == 's' && yyi < yycount) - { - yyres += symbol_name (yyarg[yyi++]); - ++yyp; - } - else - yyres += *yyp; - return yyres; - } - - - const signed char parser::yypact_ninf_ = -21; - - const signed char parser::yytable_ninf_ = -1; - - const signed char - parser::yypact_[] = - { - 2, 9, 22, -21, 19, 10, 15, 32, 11, -8, - 9, -4, -21, 2, 9, -21, 31, 33, 13, 26, - -3, 30, 25, -21, -21, -21, -4, -4, 9, -21, - 29, 37, -2, -4, -21, 27, 28, -21, -21, 34, - 35, 39, -21, -21, -21, -21, -21, 36, -21 - }; - - const signed char - parser::yydefact_[] = - { - 0, 0, 13, 8, 0, 0, 3, 13, 0, 0, - 29, 14, 1, 0, 0, 10, 5, 4, 31, 0, - 0, 28, 0, 16, 2, 9, 14, 14, 29, 11, - 0, 25, 27, 17, 12, 0, 0, 30, 23, 24, - 26, 22, 15, 7, 6, 19, 20, 21, 18 - }; - - const signed char - parser::yypgoto_[] = - { - -21, 38, -21, -1, -20, 12, 18 - }; - - const signed char - parser::yydefgoto_[] = - { - 0, 4, 5, 6, 22, 23, 19 - }; - - const signed char - parser::yytable_[] = - { - 8, 20, 30, 40, 16, 17, 35, 36, 1, 18, - 21, 31, 41, 25, 2, 1, 3, 28, 15, 12, - 13, 7, 14, 3, 14, 9, 14, 18, 10, 33, - 11, 33, 33, 29, 34, 32, 43, 44, 10, 26, - 11, 27, 39, 38, 47, 42, 37, 0, 45, 46, - 48, 24 - }; - - const signed char - parser::yycheck_[] = - { - 1, 5, 5, 5, 12, 13, 26, 27, 6, 10, - 14, 14, 14, 14, 12, 6, 14, 4, 7, 0, - 10, 12, 11, 14, 11, 3, 11, 28, 6, 4, - 8, 4, 4, 7, 9, 5, 9, 9, 6, 8, - 8, 8, 5, 14, 5, 33, 28, -1, 14, 14, - 14, 13 - }; - - const signed char - parser::yystos_[] = - { - 0, 6, 12, 14, 16, 17, 18, 12, 18, 3, - 6, 8, 0, 10, 11, 7, 12, 13, 18, 21, - 5, 14, 19, 20, 16, 18, 8, 8, 4, 7, - 5, 14, 5, 4, 9, 19, 19, 21, 14, 5, - 5, 14, 20, 9, 9, 14, 14, 5, 14 - }; - - const signed char - parser::yyr1_[] = - { - 0, 15, 16, 16, 17, 17, 17, 17, 18, 18, - 18, 18, 18, 18, 19, 19, 19, 20, 20, 20, - 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, - 21, 21 - }; - - const signed char - parser::yyr2_[] = - { - 0, 2, 3, 1, 3, 3, 6, 6, 1, 3, - 3, 4, 4, 1, 0, 3, 1, 0, 5, 4, - 4, 4, 3, 3, 3, 2, 3, 2, 1, 0, - 3, 1 - }; - - - - -#if YYDEBUG - const signed char - parser::yyrline_[] = - { - 0, 62, 62, 63, 67, 68, 69, 70, 74, 75, - 76, 77, 78, 79, 84, 85, 86, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 105, - 106, 107 - }; - - void - parser::yy_stack_print_ () const - { - *yycdebug_ << "Stack now"; - for (stack_type::const_iterator - i = yystack_.begin (), - i_end = yystack_.end (); - i != i_end; ++i) - *yycdebug_ << ' ' << int (i->state); - *yycdebug_ << '\n'; - } - - void - parser::yy_reduce_print_ (int yyrule) const - { - int yylno = yyrline_[yyrule]; - int yynrhs = yyr2_[yyrule]; - // Print the symbols being reduced, and their result. - *yycdebug_ << "Reducing stack by rule " << yyrule - 1 - << " (line " << yylno << "):\n"; - // The symbols being reduced. - for (int yyi = 0; yyi < yynrhs; yyi++) - YY_SYMBOL_PRINT (" $" << yyi + 1 << " =", - yystack_[(yynrhs) - (yyi + 1)]); - } -#endif // YYDEBUG - - -#line 6 "parser.y" -} } // adios2::detail -#line 1406 "parser.cpp" - -#line 108 "parser.y" - - -void -adios2::detail::parser::error (const location_type& l, const std::string& m) -{ - std::cerr << l << ": " << m << '\n'; -} diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h deleted file mode 100644 index 51884c287a..0000000000 --- a/source/adios2/toolkit/derived/parser/pregen-source/Windows/parser.h +++ /dev/null @@ -1,1626 +0,0 @@ -// A Bison parser, made by GNU Bison 3.8.2. - -// Skeleton interface for Bison LALR(1) parsers in C++ - -// Copyright (C) 2002-2015, 2018-2021 Free Software Foundation, Inc. - -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. - -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. - -// You should have received a copy of the GNU General Public License -// along with this program. If not, see . - -// As a special exception, you may create a larger work that contains -// part or all of the Bison parser skeleton and distribute that work -// under terms of your choice, so long as that work isn't itself a -// parser generator using the skeleton or a modified version thereof -// as a parser skeleton. Alternatively, if you modify or redistribute -// the parser skeleton itself, you may (at your option) remove this -// special exception, which will cause the skeleton and the resulting -// Bison output files to be licensed under the GNU General Public -// License without this special exception. - -// This special exception was added by the Free Software Foundation in -// version 2.2 of Bison. - - -/** - ** \file parser.h - ** Define the adios2::detail::parser class. - */ - -// C++ LALR(1) parser skeleton written by Akim Demaille. - -// DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, -// especially those whose name start with YY_ or yy_. They are -// private implementation details that can be changed or removed. - -#ifndef YY_YY_PARSER_H_INCLUDED -# define YY_YY_PARSER_H_INCLUDED -// "%code requires" blocks. -#line 11 "parser.y" - - #include - #include - #include - namespace adios2 - { - namespace detail - { - class ASTDriver; - } - } - -#line 62 "parser.h" - -# include -# include // std::abort -# include -# include -# include -# include - -#if defined __cplusplus -# define YY_CPLUSPLUS __cplusplus -#else -# define YY_CPLUSPLUS 199711L -#endif - -// Support move semantics when possible. -#if 201103L <= YY_CPLUSPLUS -# define YY_MOVE std::move -# define YY_MOVE_OR_COPY move -# define YY_MOVE_REF(Type) Type&& -# define YY_RVREF(Type) Type&& -# define YY_COPY(Type) Type -#else -# define YY_MOVE -# define YY_MOVE_OR_COPY copy -# define YY_MOVE_REF(Type) Type& -# define YY_RVREF(Type) const Type& -# define YY_COPY(Type) const Type& -#endif - -// Support noexcept when possible. -#if 201103L <= YY_CPLUSPLUS -# define YY_NOEXCEPT noexcept -# define YY_NOTHROW -#else -# define YY_NOEXCEPT -# define YY_NOTHROW throw () -#endif - -// Support constexpr when possible. -#if 201703 <= YY_CPLUSPLUS -# define YY_CONSTEXPR constexpr -#else -# define YY_CONSTEXPR -#endif -# include "location.hh" -#include -#ifndef YY_ASSERT -# include -# define YY_ASSERT assert -#endif - - -#ifndef YY_ATTRIBUTE_PURE -# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__) -# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__)) -# else -# define YY_ATTRIBUTE_PURE -# endif -#endif - -#ifndef YY_ATTRIBUTE_UNUSED -# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__) -# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__)) -# else -# define YY_ATTRIBUTE_UNUSED -# endif -#endif - -/* Suppress unused-variable warnings by "using" E. */ -#if ! defined lint || defined __GNUC__ -# define YY_USE(E) ((void) (E)) -#else -# define YY_USE(E) /* empty */ -#endif - -/* Suppress an incorrect diagnostic about yylval being uninitialized. */ -#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__ -# if __GNUC__ * 100 + __GNUC_MINOR__ < 407 -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") -# else -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \ - _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"") -# endif -# define YY_IGNORE_MAYBE_UNINITIALIZED_END \ - _Pragma ("GCC diagnostic pop") -#else -# define YY_INITIAL_VALUE(Value) Value -#endif -#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN -# define YY_IGNORE_MAYBE_UNINITIALIZED_END -#endif -#ifndef YY_INITIAL_VALUE -# define YY_INITIAL_VALUE(Value) /* Nothing. */ -#endif - -#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__ -# define YY_IGNORE_USELESS_CAST_BEGIN \ - _Pragma ("GCC diagnostic push") \ - _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"") -# define YY_IGNORE_USELESS_CAST_END \ - _Pragma ("GCC diagnostic pop") -#endif -#ifndef YY_IGNORE_USELESS_CAST_BEGIN -# define YY_IGNORE_USELESS_CAST_BEGIN -# define YY_IGNORE_USELESS_CAST_END -#endif - -# ifndef YY_CAST -# ifdef __cplusplus -# define YY_CAST(Type, Val) static_cast (Val) -# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast (Val) -# else -# define YY_CAST(Type, Val) ((Type) (Val)) -# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) -# endif -# endif -# ifndef YY_NULLPTR -# if defined __cplusplus -# if 201103L <= __cplusplus -# define YY_NULLPTR nullptr -# else -# define YY_NULLPTR 0 -# endif -# else -# define YY_NULLPTR ((void*)0) -# endif -# endif - -/* Debug traces. */ -#ifndef YYDEBUG -# define YYDEBUG 1 -#endif - -#line 6 "parser.y" -namespace adios2 { namespace detail { -#line 203 "parser.h" - - - - - /// A Bison parser. - class parser - { - public: -#ifdef YYSTYPE -# ifdef __GNUC__ -# pragma GCC message "bison: do not #define YYSTYPE in C++, use %define api.value.type" -# endif - typedef YYSTYPE value_type; -#else - /// A buffer to store and retrieve objects. - /// - /// Sort of a variant, but does not keep track of the nature - /// of the stored data, since that knowledge is available - /// via the current parser state. - class value_type - { - public: - /// Type of *this. - typedef value_type self_type; - - /// Empty construction. - value_type () YY_NOEXCEPT - : yyraw_ () - , yytypeid_ (YY_NULLPTR) - {} - - /// Construct and fill. - template - value_type (YY_RVREF (T) t) - : yytypeid_ (&typeid (T)) - { - YY_ASSERT (sizeof (T) <= size); - new (yyas_ ()) T (YY_MOVE (t)); - } - -#if 201103L <= YY_CPLUSPLUS - /// Non copyable. - value_type (const self_type&) = delete; - /// Non copyable. - self_type& operator= (const self_type&) = delete; -#endif - - /// Destruction, allowed only if empty. - ~value_type () YY_NOEXCEPT - { - YY_ASSERT (!yytypeid_); - } - -# if 201103L <= YY_CPLUSPLUS - /// Instantiate a \a T in here from \a t. - template - T& - emplace (U&&... u) - { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); - yytypeid_ = & typeid (T); - return *new (yyas_ ()) T (std::forward (u)...); - } -# else - /// Instantiate an empty \a T in here. - template - T& - emplace () - { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); - yytypeid_ = & typeid (T); - return *new (yyas_ ()) T (); - } - - /// Instantiate a \a T in here from \a t. - template - T& - emplace (const T& t) - { - YY_ASSERT (!yytypeid_); - YY_ASSERT (sizeof (T) <= size); - yytypeid_ = & typeid (T); - return *new (yyas_ ()) T (t); - } -# endif - - /// Instantiate an empty \a T in here. - /// Obsolete, use emplace. - template - T& - build () - { - return emplace (); - } - - /// Instantiate a \a T in here from \a t. - /// Obsolete, use emplace. - template - T& - build (const T& t) - { - return emplace (t); - } - - /// Accessor to a built \a T. - template - T& - as () YY_NOEXCEPT - { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == typeid (T)); - YY_ASSERT (sizeof (T) <= size); - return *yyas_ (); - } - - /// Const accessor to a built \a T (for %printer). - template - const T& - as () const YY_NOEXCEPT - { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == typeid (T)); - YY_ASSERT (sizeof (T) <= size); - return *yyas_ (); - } - - /// Swap the content with \a that, of same type. - /// - /// Both variants must be built beforehand, because swapping the actual - /// data requires reading it (with as()), and this is not possible on - /// unconstructed variants: it would require some dynamic testing, which - /// should not be the variant's responsibility. - /// Swapping between built and (possibly) non-built is done with - /// self_type::move (). - template - void - swap (self_type& that) YY_NOEXCEPT - { - YY_ASSERT (yytypeid_); - YY_ASSERT (*yytypeid_ == *that.yytypeid_); - std::swap (as (), that.as ()); - } - - /// Move the content of \a that to this. - /// - /// Destroys \a that. - template - void - move (self_type& that) - { -# if 201103L <= YY_CPLUSPLUS - emplace (std::move (that.as ())); -# else - emplace (); - swap (that); -# endif - that.destroy (); - } - -# if 201103L <= YY_CPLUSPLUS - /// Move the content of \a that to this. - template - void - move (self_type&& that) - { - emplace (std::move (that.as ())); - that.destroy (); - } -#endif - - /// Copy the content of \a that to this. - template - void - copy (const self_type& that) - { - emplace (that.as ()); - } - - /// Destroy the stored \a T. - template - void - destroy () - { - as ().~T (); - yytypeid_ = YY_NULLPTR; - } - - private: -#if YY_CPLUSPLUS < 201103L - /// Non copyable. - value_type (const self_type&); - /// Non copyable. - self_type& operator= (const self_type&); -#endif - - /// Accessor to raw memory as \a T. - template - T* - yyas_ () YY_NOEXCEPT - { - void *yyp = yyraw_; - return static_cast (yyp); - } - - /// Const accessor to raw memory as \a T. - template - const T* - yyas_ () const YY_NOEXCEPT - { - const void *yyp = yyraw_; - return static_cast (yyp); - } - - /// An auxiliary type to compute the largest semantic type. - union union_type - { - // "number" - // list - char dummy1[sizeof (int)]; - - // OPERATOR - // "identifier" - // VARNAME - char dummy2[sizeof (std::string)]; - - // index - char dummy3[sizeof (std::tuple)]; - - // indices_list - char dummy4[sizeof (std::vector>)]; - }; - - /// The size of the largest semantic type. - enum { size = sizeof (union_type) }; - - /// A buffer to store semantic values. - union - { - /// Strongest alignment constraints. - long double yyalign_me_; - /// A buffer large enough to store any of the semantic values. - char yyraw_[size]; - }; - - /// Whether the content is built: if defined, the name of the stored type. - const std::type_info *yytypeid_; - }; - -#endif - /// Backward compatibility (Bison 3.8). - typedef value_type semantic_type; - - /// Symbol locations. - typedef location location_type; - - /// Syntax errors thrown from user actions. - struct syntax_error : std::runtime_error - { - syntax_error (const location_type& l, const std::string& m) - : std::runtime_error (m) - , location (l) - {} - - syntax_error (const syntax_error& s) - : std::runtime_error (s.what ()) - , location (s.location) - {} - - ~syntax_error () YY_NOEXCEPT YY_NOTHROW; - - location_type location; - }; - - /// Token kinds. - struct token - { - enum token_kind_type - { - TOK_YYEMPTY = -2, - TOK_YYEOF = 0, // "end of file" - TOK_YYerror = 1, // error - TOK_YYUNDEF = 2, // "invalid token" - TOK_ASSIGN = 3, // "=" - TOK_COMMA = 4, // "," - TOK_COLON = 5, // ":" - TOK_L_PAREN = 6, // "(" - TOK_R_PAREN = 7, // ")" - TOK_L_BRACE = 8, // "[" - TOK_R_BRACE = 9, // "]" - TOK_ENDL = 10, // "\n" - TOK_OPERATOR = 11, // OPERATOR - TOK_IDENTIFIER = 12, // "identifier" - TOK_VARNAME = 13, // VARNAME - TOK_INT = 14 // "number" - }; - /// Backward compatibility alias (Bison 3.6). - typedef token_kind_type yytokentype; - }; - - /// Token kind, as returned by yylex. - typedef token::token_kind_type token_kind_type; - - /// Backward compatibility alias (Bison 3.6). - typedef token_kind_type token_type; - - /// Symbol kinds. - struct symbol_kind - { - enum symbol_kind_type - { - YYNTOKENS = 15, ///< Number of tokens. - S_YYEMPTY = -2, - S_YYEOF = 0, // "end of file" - S_YYerror = 1, // error - S_YYUNDEF = 2, // "invalid token" - S_ASSIGN = 3, // "=" - S_COMMA = 4, // "," - S_COLON = 5, // ":" - S_L_PAREN = 6, // "(" - S_R_PAREN = 7, // ")" - S_L_BRACE = 8, // "[" - S_R_BRACE = 9, // "]" - S_ENDL = 10, // "\n" - S_OPERATOR = 11, // OPERATOR - S_IDENTIFIER = 12, // "identifier" - S_VARNAME = 13, // VARNAME - S_INT = 14, // "number" - S_YYACCEPT = 15, // $accept - S_lines = 16, // lines - S_assignment = 17, // assignment - S_exp = 18, // exp - S_indices_list = 19, // indices_list - S_index = 20, // index - S_list = 21 // list - }; - }; - - /// (Internal) symbol kind. - typedef symbol_kind::symbol_kind_type symbol_kind_type; - - /// The number of tokens. - static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS; - - /// A complete symbol. - /// - /// Expects its Base type to provide access to the symbol kind - /// via kind (). - /// - /// Provide access to semantic value and location. - template - struct basic_symbol : Base - { - /// Alias to Base. - typedef Base super_type; - - /// Default constructor. - basic_symbol () YY_NOEXCEPT - : value () - , location () - {} - -#if 201103L <= YY_CPLUSPLUS - /// Move constructor. - basic_symbol (basic_symbol&& that) - : Base (std::move (that)) - , value () - , location (std::move (that.location)) - { - switch (this->kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.move< int > (std::move (that.value)); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.move< std::string > (std::move (that.value)); - break; - - case symbol_kind::S_index: // index - value.move< std::tuple > (std::move (that.value)); - break; - - case symbol_kind::S_indices_list: // indices_list - value.move< std::vector> > (std::move (that.value)); - break; - - default: - break; - } - - } -#endif - - /// Copy constructor. - basic_symbol (const basic_symbol& that); - - /// Constructors for typed symbols. -#if 201103L <= YY_CPLUSPLUS - basic_symbol (typename Base::kind_type t, location_type&& l) - : Base (t) - , location (std::move (l)) - {} -#else - basic_symbol (typename Base::kind_type t, const location_type& l) - : Base (t) - , location (l) - {} -#endif - -#if 201103L <= YY_CPLUSPLUS - basic_symbol (typename Base::kind_type t, int&& v, location_type&& l) - : Base (t) - , value (std::move (v)) - , location (std::move (l)) - {} -#else - basic_symbol (typename Base::kind_type t, const int& v, const location_type& l) - : Base (t) - , value (v) - , location (l) - {} -#endif - -#if 201103L <= YY_CPLUSPLUS - basic_symbol (typename Base::kind_type t, std::string&& v, location_type&& l) - : Base (t) - , value (std::move (v)) - , location (std::move (l)) - {} -#else - basic_symbol (typename Base::kind_type t, const std::string& v, const location_type& l) - : Base (t) - , value (v) - , location (l) - {} -#endif - -#if 201103L <= YY_CPLUSPLUS - basic_symbol (typename Base::kind_type t, std::tuple&& v, location_type&& l) - : Base (t) - , value (std::move (v)) - , location (std::move (l)) - {} -#else - basic_symbol (typename Base::kind_type t, const std::tuple& v, const location_type& l) - : Base (t) - , value (v) - , location (l) - {} -#endif - -#if 201103L <= YY_CPLUSPLUS - basic_symbol (typename Base::kind_type t, std::vector>&& v, location_type&& l) - : Base (t) - , value (std::move (v)) - , location (std::move (l)) - {} -#else - basic_symbol (typename Base::kind_type t, const std::vector>& v, const location_type& l) - : Base (t) - , value (v) - , location (l) - {} -#endif - - /// Destroy the symbol. - ~basic_symbol () - { - clear (); - } - - - - /// Destroy contents, and record that is empty. - void clear () YY_NOEXCEPT - { - // User destructor. - symbol_kind_type yykind = this->kind (); - basic_symbol& yysym = *this; - (void) yysym; - switch (yykind) - { - default: - break; - } - - // Value type destructor. -switch (yykind) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.template destroy< int > (); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.template destroy< std::string > (); - break; - - case symbol_kind::S_index: // index - value.template destroy< std::tuple > (); - break; - - case symbol_kind::S_indices_list: // indices_list - value.template destroy< std::vector> > (); - break; - - default: - break; - } - - Base::clear (); - } - - /// The user-facing name of this symbol. - const char *name () const YY_NOEXCEPT - { - return parser::symbol_name (this->kind ()); - } - - /// Backward compatibility (Bison 3.6). - symbol_kind_type type_get () const YY_NOEXCEPT; - - /// Whether empty. - bool empty () const YY_NOEXCEPT; - - /// Destructive move, \a s is emptied into this. - void move (basic_symbol& s); - - /// The semantic value. - value_type value; - - /// The location. - location_type location; - - private: -#if YY_CPLUSPLUS < 201103L - /// Assignment operator. - basic_symbol& operator= (const basic_symbol& that); -#endif - }; - - /// Type access provider for token (enum) based symbols. - struct by_kind - { - /// The symbol kind as needed by the constructor. - typedef token_kind_type kind_type; - - /// Default constructor. - by_kind () YY_NOEXCEPT; - -#if 201103L <= YY_CPLUSPLUS - /// Move constructor. - by_kind (by_kind&& that) YY_NOEXCEPT; -#endif - - /// Copy constructor. - by_kind (const by_kind& that) YY_NOEXCEPT; - - /// Constructor from (external) token numbers. - by_kind (kind_type t) YY_NOEXCEPT; - - - - /// Record that this symbol is empty. - void clear () YY_NOEXCEPT; - - /// Steal the symbol kind from \a that. - void move (by_kind& that); - - /// The (internal) type number (corresponding to \a type). - /// \a empty when empty. - symbol_kind_type kind () const YY_NOEXCEPT; - - /// Backward compatibility (Bison 3.6). - symbol_kind_type type_get () const YY_NOEXCEPT; - - /// The symbol kind. - /// \a S_YYEMPTY when empty. - symbol_kind_type kind_; - }; - - /// Backward compatibility for a private implementation detail (Bison 3.6). - typedef by_kind by_type; - - /// "External" symbols: returned by the scanner. - struct symbol_type : basic_symbol - { - /// Superclass. - typedef basic_symbol super_type; - - /// Empty symbol. - symbol_type () YY_NOEXCEPT {} - - /// Constructor for valueless symbols, and symbols from each type. -#if 201103L <= YY_CPLUSPLUS - symbol_type (int tok, location_type l) - : super_type (token_kind_type (tok), std::move (l)) -#else - symbol_type (int tok, const location_type& l) - : super_type (token_kind_type (tok), l) -#endif - { -#if !defined _MSC_VER || defined __clang__ - YY_ASSERT (tok == token::TOK_YYEOF - || (token::TOK_YYerror <= tok && tok <= token::TOK_ENDL)); -#endif - } -#if 201103L <= YY_CPLUSPLUS - symbol_type (int tok, int v, location_type l) - : super_type (token_kind_type (tok), std::move (v), std::move (l)) -#else - symbol_type (int tok, const int& v, const location_type& l) - : super_type (token_kind_type (tok), v, l) -#endif - { -#if !defined _MSC_VER || defined __clang__ - YY_ASSERT (tok == token::TOK_INT); -#endif - } -#if 201103L <= YY_CPLUSPLUS - symbol_type (int tok, std::string v, location_type l) - : super_type (token_kind_type (tok), std::move (v), std::move (l)) -#else - symbol_type (int tok, const std::string& v, const location_type& l) - : super_type (token_kind_type (tok), v, l) -#endif - { -#if !defined _MSC_VER || defined __clang__ - YY_ASSERT ((token::TOK_OPERATOR <= tok && tok <= token::TOK_VARNAME)); -#endif - } - }; - - /// Build a parser object. - parser (ASTDriver& drv_yyarg); - virtual ~parser (); - -#if 201103L <= YY_CPLUSPLUS - /// Non copyable. - parser (const parser&) = delete; - /// Non copyable. - parser& operator= (const parser&) = delete; -#endif - - /// Parse. An alias for parse (). - /// \returns 0 iff parsing succeeded. - int operator() (); - - /// Parse. - /// \returns 0 iff parsing succeeded. - virtual int parse (); - -#if YYDEBUG - /// The current debugging stream. - std::ostream& debug_stream () const YY_ATTRIBUTE_PURE; - /// Set the current debugging stream. - void set_debug_stream (std::ostream &); - - /// Type for debugging levels. - typedef int debug_level_type; - /// The current debugging level. - debug_level_type debug_level () const YY_ATTRIBUTE_PURE; - /// Set the current debugging level. - void set_debug_level (debug_level_type l); -#endif - - /// Report a syntax error. - /// \param loc where the syntax error is found. - /// \param msg a description of the syntax error. - virtual void error (const location_type& loc, const std::string& msg); - - /// Report a syntax error. - void error (const syntax_error& err); - - /// The user-facing name of the symbol whose (internal) number is - /// YYSYMBOL. No bounds checking. - static const char *symbol_name (symbol_kind_type yysymbol); - - // Implementation of make_symbol for each token kind. -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_YYEOF (location_type l) - { - return symbol_type (token::TOK_YYEOF, std::move (l)); - } -#else - static - symbol_type - make_YYEOF (const location_type& l) - { - return symbol_type (token::TOK_YYEOF, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_YYerror (location_type l) - { - return symbol_type (token::TOK_YYerror, std::move (l)); - } -#else - static - symbol_type - make_YYerror (const location_type& l) - { - return symbol_type (token::TOK_YYerror, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_YYUNDEF (location_type l) - { - return symbol_type (token::TOK_YYUNDEF, std::move (l)); - } -#else - static - symbol_type - make_YYUNDEF (const location_type& l) - { - return symbol_type (token::TOK_YYUNDEF, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_ASSIGN (location_type l) - { - return symbol_type (token::TOK_ASSIGN, std::move (l)); - } -#else - static - symbol_type - make_ASSIGN (const location_type& l) - { - return symbol_type (token::TOK_ASSIGN, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_COMMA (location_type l) - { - return symbol_type (token::TOK_COMMA, std::move (l)); - } -#else - static - symbol_type - make_COMMA (const location_type& l) - { - return symbol_type (token::TOK_COMMA, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_COLON (location_type l) - { - return symbol_type (token::TOK_COLON, std::move (l)); - } -#else - static - symbol_type - make_COLON (const location_type& l) - { - return symbol_type (token::TOK_COLON, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_L_PAREN (location_type l) - { - return symbol_type (token::TOK_L_PAREN, std::move (l)); - } -#else - static - symbol_type - make_L_PAREN (const location_type& l) - { - return symbol_type (token::TOK_L_PAREN, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_R_PAREN (location_type l) - { - return symbol_type (token::TOK_R_PAREN, std::move (l)); - } -#else - static - symbol_type - make_R_PAREN (const location_type& l) - { - return symbol_type (token::TOK_R_PAREN, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_L_BRACE (location_type l) - { - return symbol_type (token::TOK_L_BRACE, std::move (l)); - } -#else - static - symbol_type - make_L_BRACE (const location_type& l) - { - return symbol_type (token::TOK_L_BRACE, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_R_BRACE (location_type l) - { - return symbol_type (token::TOK_R_BRACE, std::move (l)); - } -#else - static - symbol_type - make_R_BRACE (const location_type& l) - { - return symbol_type (token::TOK_R_BRACE, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_ENDL (location_type l) - { - return symbol_type (token::TOK_ENDL, std::move (l)); - } -#else - static - symbol_type - make_ENDL (const location_type& l) - { - return symbol_type (token::TOK_ENDL, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_OPERATOR (std::string v, location_type l) - { - return symbol_type (token::TOK_OPERATOR, std::move (v), std::move (l)); - } -#else - static - symbol_type - make_OPERATOR (const std::string& v, const location_type& l) - { - return symbol_type (token::TOK_OPERATOR, v, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_IDENTIFIER (std::string v, location_type l) - { - return symbol_type (token::TOK_IDENTIFIER, std::move (v), std::move (l)); - } -#else - static - symbol_type - make_IDENTIFIER (const std::string& v, const location_type& l) - { - return symbol_type (token::TOK_IDENTIFIER, v, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_VARNAME (std::string v, location_type l) - { - return symbol_type (token::TOK_VARNAME, std::move (v), std::move (l)); - } -#else - static - symbol_type - make_VARNAME (const std::string& v, const location_type& l) - { - return symbol_type (token::TOK_VARNAME, v, l); - } -#endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_INT (int v, location_type l) - { - return symbol_type (token::TOK_INT, std::move (v), std::move (l)); - } -#else - static - symbol_type - make_INT (const int& v, const location_type& l) - { - return symbol_type (token::TOK_INT, v, l); - } -#endif - - - class context - { - public: - context (const parser& yyparser, const symbol_type& yyla); - const symbol_type& lookahead () const YY_NOEXCEPT { return yyla_; } - symbol_kind_type token () const YY_NOEXCEPT { return yyla_.kind (); } - const location_type& location () const YY_NOEXCEPT { return yyla_.location; } - - /// Put in YYARG at most YYARGN of the expected tokens, and return the - /// number of tokens stored in YYARG. If YYARG is null, return the - /// number of expected tokens (guaranteed to be less than YYNTOKENS). - int expected_tokens (symbol_kind_type yyarg[], int yyargn) const; - - private: - const parser& yyparser_; - const symbol_type& yyla_; - }; - - private: -#if YY_CPLUSPLUS < 201103L - /// Non copyable. - parser (const parser&); - /// Non copyable. - parser& operator= (const parser&); -#endif - - /// Check the lookahead yytoken. - /// \returns true iff the token will be eventually shifted. - bool yy_lac_check_ (symbol_kind_type yytoken) const; - /// Establish the initial context if no initial context currently exists. - /// \returns true iff the token will be eventually shifted. - bool yy_lac_establish_ (symbol_kind_type yytoken); - /// Discard any previous initial lookahead context because of event. - /// \param event the event which caused the lookahead to be discarded. - /// Only used for debbuging output. - void yy_lac_discard_ (const char* event); - - /// Stored state numbers (used for stacks). - typedef signed char state_type; - - /// The arguments of the error message. - int yy_syntax_error_arguments_ (const context& yyctx, - symbol_kind_type yyarg[], int yyargn) const; - - /// Generate an error message. - /// \param yyctx the context in which the error occurred. - virtual std::string yysyntax_error_ (const context& yyctx) const; - /// Compute post-reduction state. - /// \param yystate the current state - /// \param yysym the nonterminal to push on the stack - static state_type yy_lr_goto_state_ (state_type yystate, int yysym); - - /// Whether the given \c yypact_ value indicates a defaulted state. - /// \param yyvalue the value to check - static bool yy_pact_value_is_default_ (int yyvalue) YY_NOEXCEPT; - - /// Whether the given \c yytable_ value indicates a syntax error. - /// \param yyvalue the value to check - static bool yy_table_value_is_error_ (int yyvalue) YY_NOEXCEPT; - - static const signed char yypact_ninf_; - static const signed char yytable_ninf_; - - /// Convert a scanner token kind \a t to a symbol kind. - /// In theory \a t should be a token_kind_type, but character literals - /// are valid, yet not members of the token_kind_type enum. - static symbol_kind_type yytranslate_ (int t) YY_NOEXCEPT; - - - - // Tables. - // YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - // STATE-NUM. - static const signed char yypact_[]; - - // YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM. - // Performed when YYTABLE does not specify something else to do. Zero - // means the default is an error. - static const signed char yydefact_[]; - - // YYPGOTO[NTERM-NUM]. - static const signed char yypgoto_[]; - - // YYDEFGOTO[NTERM-NUM]. - static const signed char yydefgoto_[]; - - // YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If - // positive, shift that token. If negative, reduce the rule whose - // number is the opposite. If YYTABLE_NINF, syntax error. - static const signed char yytable_[]; - - static const signed char yycheck_[]; - - // YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of - // state STATE-NUM. - static const signed char yystos_[]; - - // YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. - static const signed char yyr1_[]; - - // YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. - static const signed char yyr2_[]; - - -#if YYDEBUG - // YYRLINE[YYN] -- Source line where rule number YYN was defined. - static const signed char yyrline_[]; - /// Report on the debug stream that the rule \a r is going to be reduced. - virtual void yy_reduce_print_ (int r) const; - /// Print the state stack on the debug stream. - virtual void yy_stack_print_ () const; - - /// Debugging level. - int yydebug_; - /// Debug stream. - std::ostream* yycdebug_; - - /// \brief Display a symbol kind, value and location. - /// \param yyo The output stream. - /// \param yysym The symbol. - template - void yy_print_ (std::ostream& yyo, const basic_symbol& yysym) const; -#endif - - /// \brief Reclaim the memory associated to a symbol. - /// \param yymsg Why this token is reclaimed. - /// If null, print nothing. - /// \param yysym The symbol. - template - void yy_destroy_ (const char* yymsg, basic_symbol& yysym) const; - - private: - /// Type access provider for state based symbols. - struct by_state - { - /// Default constructor. - by_state () YY_NOEXCEPT; - - /// The symbol kind as needed by the constructor. - typedef state_type kind_type; - - /// Constructor. - by_state (kind_type s) YY_NOEXCEPT; - - /// Copy constructor. - by_state (const by_state& that) YY_NOEXCEPT; - - /// Record that this symbol is empty. - void clear () YY_NOEXCEPT; - - /// Steal the symbol kind from \a that. - void move (by_state& that); - - /// The symbol kind (corresponding to \a state). - /// \a symbol_kind::S_YYEMPTY when empty. - symbol_kind_type kind () const YY_NOEXCEPT; - - /// The state number used to denote an empty symbol. - /// We use the initial state, as it does not have a value. - enum { empty_state = 0 }; - - /// The state. - /// \a empty when empty. - state_type state; - }; - - /// "Internal" symbol: element of the stack. - struct stack_symbol_type : basic_symbol - { - /// Superclass. - typedef basic_symbol super_type; - /// Construct an empty symbol. - stack_symbol_type (); - /// Move or copy construction. - stack_symbol_type (YY_RVREF (stack_symbol_type) that); - /// Steal the contents from \a sym to build this. - stack_symbol_type (state_type s, YY_MOVE_REF (symbol_type) sym); -#if YY_CPLUSPLUS < 201103L - /// Assignment, needed by push_back by some old implementations. - /// Moves the contents of that. - stack_symbol_type& operator= (stack_symbol_type& that); - - /// Assignment, needed by push_back by other implementations. - /// Needed by some other old implementations. - stack_symbol_type& operator= (const stack_symbol_type& that); -#endif - }; - - /// A stack with random access from its top. - template > - class stack - { - public: - // Hide our reversed order. - typedef typename S::iterator iterator; - typedef typename S::const_iterator const_iterator; - typedef typename S::size_type size_type; - typedef typename std::ptrdiff_t index_type; - - stack (size_type n = 200) YY_NOEXCEPT - : seq_ (n) - {} - -#if 201103L <= YY_CPLUSPLUS - /// Non copyable. - stack (const stack&) = delete; - /// Non copyable. - stack& operator= (const stack&) = delete; -#endif - - /// Random access. - /// - /// Index 0 returns the topmost element. - const T& - operator[] (index_type i) const - { - return seq_[size_type (size () - 1 - i)]; - } - - /// Random access. - /// - /// Index 0 returns the topmost element. - T& - operator[] (index_type i) - { - return seq_[size_type (size () - 1 - i)]; - } - - /// Steal the contents of \a t. - /// - /// Close to move-semantics. - void - push (YY_MOVE_REF (T) t) - { - seq_.push_back (T ()); - operator[] (0).move (t); - } - - /// Pop elements from the stack. - void - pop (std::ptrdiff_t n = 1) YY_NOEXCEPT - { - for (; 0 < n; --n) - seq_.pop_back (); - } - - /// Pop all elements from the stack. - void - clear () YY_NOEXCEPT - { - seq_.clear (); - } - - /// Number of elements on the stack. - index_type - size () const YY_NOEXCEPT - { - return index_type (seq_.size ()); - } - - /// Iterator on top of the stack (going downwards). - const_iterator - begin () const YY_NOEXCEPT - { - return seq_.begin (); - } - - /// Bottom of the stack. - const_iterator - end () const YY_NOEXCEPT - { - return seq_.end (); - } - - /// Present a slice of the top of a stack. - class slice - { - public: - slice (const stack& stack, index_type range) YY_NOEXCEPT - : stack_ (stack) - , range_ (range) - {} - - const T& - operator[] (index_type i) const - { - return stack_[range_ - i]; - } - - private: - const stack& stack_; - index_type range_; - }; - - private: -#if YY_CPLUSPLUS < 201103L - /// Non copyable. - stack (const stack&); - /// Non copyable. - stack& operator= (const stack&); -#endif - /// The wrapped container. - S seq_; - }; - - - /// Stack type. - typedef stack stack_type; - - /// The stack. - stack_type yystack_; - /// The stack for LAC. - /// Logically, the yy_lac_stack's lifetime is confined to the function - /// yy_lac_check_. We just store it as a member of this class to hold - /// on to the memory and to avoid frequent reallocations. - /// Since yy_lac_check_ is const, this member must be mutable. - mutable std::vector yylac_stack_; - /// Whether an initial LAC context was established. - bool yy_lac_established_; - - - /// Push a new state on the stack. - /// \param m a debug message to display - /// if null, no trace is output. - /// \param sym the symbol - /// \warning the contents of \a s.value is stolen. - void yypush_ (const char* m, YY_MOVE_REF (stack_symbol_type) sym); - - /// Push a new look ahead token on the state on the stack. - /// \param m a debug message to display - /// if null, no trace is output. - /// \param s the state - /// \param sym the symbol (for its value and location). - /// \warning the contents of \a sym.value is stolen. - void yypush_ (const char* m, state_type s, YY_MOVE_REF (symbol_type) sym); - - /// Pop \a n symbols from the stack. - void yypop_ (int n = 1) YY_NOEXCEPT; - - /// Constants. - enum - { - yylast_ = 51, ///< Last index in yytable_. - yynnts_ = 7, ///< Number of nonterminal symbols. - yyfinal_ = 12 ///< Termination state number. - }; - - - // User arguments. - ASTDriver& drv; - - }; - - inline - parser::symbol_kind_type - parser::yytranslate_ (int t) YY_NOEXCEPT - { - return static_cast (t); - } - - // basic_symbol. - template - parser::basic_symbol::basic_symbol (const basic_symbol& that) - : Base (that) - , value () - , location (that.location) - { - switch (this->kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.copy< int > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.copy< std::string > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_index: // index - value.copy< std::tuple > (YY_MOVE (that.value)); - break; - - case symbol_kind::S_indices_list: // indices_list - value.copy< std::vector> > (YY_MOVE (that.value)); - break; - - default: - break; - } - - } - - - - - template - parser::symbol_kind_type - parser::basic_symbol::type_get () const YY_NOEXCEPT - { - return this->kind (); - } - - - template - bool - parser::basic_symbol::empty () const YY_NOEXCEPT - { - return this->kind () == symbol_kind::S_YYEMPTY; - } - - template - void - parser::basic_symbol::move (basic_symbol& s) - { - super_type::move (s); - switch (this->kind ()) - { - case symbol_kind::S_INT: // "number" - case symbol_kind::S_list: // list - value.move< int > (YY_MOVE (s.value)); - break; - - case symbol_kind::S_OPERATOR: // OPERATOR - case symbol_kind::S_IDENTIFIER: // "identifier" - case symbol_kind::S_VARNAME: // VARNAME - value.move< std::string > (YY_MOVE (s.value)); - break; - - case symbol_kind::S_index: // index - value.move< std::tuple > (YY_MOVE (s.value)); - break; - - case symbol_kind::S_indices_list: // indices_list - value.move< std::vector> > (YY_MOVE (s.value)); - break; - - default: - break; - } - - location = YY_MOVE (s.location); - } - - // by_kind. - inline - parser::by_kind::by_kind () YY_NOEXCEPT - : kind_ (symbol_kind::S_YYEMPTY) - {} - -#if 201103L <= YY_CPLUSPLUS - inline - parser::by_kind::by_kind (by_kind&& that) YY_NOEXCEPT - : kind_ (that.kind_) - { - that.clear (); - } -#endif - - inline - parser::by_kind::by_kind (const by_kind& that) YY_NOEXCEPT - : kind_ (that.kind_) - {} - - inline - parser::by_kind::by_kind (token_kind_type t) YY_NOEXCEPT - : kind_ (yytranslate_ (t)) - {} - - - - inline - void - parser::by_kind::clear () YY_NOEXCEPT - { - kind_ = symbol_kind::S_YYEMPTY; - } - - inline - void - parser::by_kind::move (by_kind& that) - { - kind_ = that.kind_; - that.clear (); - } - - inline - parser::symbol_kind_type - parser::by_kind::kind () const YY_NOEXCEPT - { - return kind_; - } - - - inline - parser::symbol_kind_type - parser::by_kind::type_get () const YY_NOEXCEPT - { - return this->kind (); - } - - -#line 6 "parser.y" -} } // adios2::detail -#line 1622 "parser.h" - - - - -#endif // !YY_YY_PARSER_H_INCLUDED diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp similarity index 99% rename from source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp rename to source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index a8361f032e..61b3f506af 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -17,7 +17,6 @@ /* First, we deal with platform-specific or compiler-specific issues. */ /* begin standard C headers. */ -#include #include #include #include diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/Windows/lexer.h rename to source/adios2/toolkit/derived/parser/pregen-source/lexer.h diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Linux/location.hh b/source/adios2/toolkit/derived/parser/pregen-source/location.hh similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/Linux/location.hh rename to source/adios2/toolkit/derived/parser/pregen-source/location.hh diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.cpp rename to source/adios2/toolkit/derived/parser/pregen-source/parser.cpp diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/parser.h similarity index 100% rename from source/adios2/toolkit/derived/parser/pregen-source/Linux/parser.h rename to source/adios2/toolkit/derived/parser/pregen-source/parser.h diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index d14b931639..ce25eb010b 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -70,7 +70,7 @@ TEST(DerivedCorrectness, AddCorrectnessTest) std::vector readAdd; float calcA; - float epsilon = 0.01; + float epsilon = (float)0.01; for (size_t i = 0; i < steps; i++) { bpFileReader.BeginStep(); @@ -145,7 +145,7 @@ TEST(DerivedCorrectness, MagCorrectnessTest) std::vector readMag; float calcM; - float epsilon = 0.01; + float epsilon = (float)0.01; for (size_t i = 0; i < steps; i++) { bpFileReader.BeginStep(); @@ -162,7 +162,7 @@ TEST(DerivedCorrectness, MagCorrectnessTest) for (size_t ind = 0; ind < Nx * Ny * Nz; ++ind) { - calcM = sqrt(pow(readUx[ind], 2) + pow(readUy[ind], 2) + pow(readUz[ind], 2)); + calcM = (float) sqrt(pow(readUx[ind], 2) + pow(readUy[ind], 2) + pow(readUz[ind], 2)); EXPECT_TRUE(fabs(calcM - readMag[ind]) < epsilon); } } From 88e086af1cf32714ecc189badf4f516ac4d2175c Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 7 Mar 2024 18:44:58 -0500 Subject: [PATCH 27/46] clang-format --- source/adios2/toolkit/derived/Function.cpp | 2 +- testing/adios2/derived/TestBPDerivedCorrectness.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/source/adios2/toolkit/derived/Function.cpp b/source/adios2/toolkit/derived/Function.cpp index 0e49d9a6a7..cb145d8927 100644 --- a/source/adios2/toolkit/derived/Function.cpp +++ b/source/adios2/toolkit/derived/Function.cpp @@ -39,7 +39,7 @@ DerivedData MagnitudeFunc(std::vector inputData, DataType type) T *magValues = ApplyOneToOne(inputData, dataSize, [](T a, T b) { return a + b * b; }); \ for (size_t i = 0; i < dataSize; i++) \ { \ - magValues[i] = (T) std::sqrt(magValues[i]); \ + magValues[i] = (T)std::sqrt(magValues[i]); \ } \ return DerivedData({(void *)magValues, inputData[0].Start, inputData[0].Count}); \ } diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index ce25eb010b..886b942db3 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -162,7 +162,7 @@ TEST(DerivedCorrectness, MagCorrectnessTest) for (size_t ind = 0; ind < Nx * Ny * Nz; ++ind) { - calcM = (float) sqrt(pow(readUx[ind], 2) + pow(readUy[ind], 2) + pow(readUz[ind], 2)); + calcM = (float)sqrt(pow(readUx[ind], 2) + pow(readUy[ind], 2) + pow(readUz[ind], 2)); EXPECT_TRUE(fabs(calcM - readMag[ind]) < epsilon); } } From cab0730111d51f89a852bd948ab8564ae257a65d Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 7 Mar 2024 23:50:17 +0000 Subject: [PATCH 28/46] Whoops, remove windows specific from general target --- source/adios2/CMakeLists.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index cfc22b8151..6c7a9f2282 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -136,7 +136,6 @@ if (ADIOS2_HAVE_Derived_Variable) toolkit/derived/Function.cpp toolkit/derived/Function.tcc toolkit/derived/ExprHelper.h) set_target_properties(adios2_core PROPERTIES - COMPILE_FLAGS "/wd4005 /wd4065 /wd4267 -DYY_NO_UNISTD_H" INCLUDE_DIRECTORIES "$;$") find_package(BISON "3.8.2") find_package(FLEX) From fd8750791e2226aa4db0aa32f52338e318cf4d16 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 7 Mar 2024 23:57:07 +0000 Subject: [PATCH 29/46] Win Tweaks --- source/adios2/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index 6c7a9f2282..1577ab136c 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -160,6 +160,8 @@ if (ADIOS2_HAVE_Derived_Variable) SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp PROPERTIES COMPILE_FLAGS -Wno-sign-compare) elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/parser.cpp PROPERTIES COMPILE_FLAGS -Wno-unused-but-set-variable) + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + SET_SOURCE_FILES_PROPERTIES(toolkit/derived/Expression.cpp toolkit/derived/Function.cpp PROPERTIES COMPILE_FLAGS "/wd4005 /wd4065 /wd4267 -DYY_NO_UNISTD_H") endif() add_library(adios2_core_derived ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp From f20ee6aa5059064154f3238ace2b419780737b39 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 7 Mar 2024 19:58:41 -0500 Subject: [PATCH 30/46] limits.h --- source/adios2/toolkit/derived/parser/lexer.l | 1 + .../derived/parser/pregen-source/lexer.cpp | 92 ++++++++++--------- .../derived/parser/pregen-source/lexer.h | 13 +-- 3 files changed, 55 insertions(+), 51 deletions(-) diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index cee069ec30..11fbe9d75b 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -1,6 +1,7 @@ %{ #include #include +#include #include // strerror #include #include "ASTDriver.h" diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index 61b3f506af..02c931a5d9 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -47,6 +47,7 @@ typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; +typedef uint64_t flex_uint64_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; @@ -155,7 +156,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif -extern int yyleng; +extern yy_size_t yyleng; extern FILE *yyin, *yyout; @@ -198,7 +199,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - int yy_n_chars; + yy_size_t yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -267,8 +268,8 @@ static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */ /* yy_hold_char holds the character lost when yytext is formed. */ static char yy_hold_char; -static int yy_n_chars; /* number of characters read into yy_ch_buf */ -int yyleng; +static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */ +yy_size_t yyleng; /* Points to current character in buffer. */ static char *yy_c_buf_p = NULL; @@ -295,7 +296,7 @@ static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file ); YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); void *yyalloc ( yy_size_t ); void *yyrealloc ( void *, yy_size_t ); @@ -351,7 +352,7 @@ static void yynoreturn yy_fatal_error ( const char* msg ); */ #define YY_DO_BEFORE_ACTION \ (yytext_ptr) = yy_bp; \ - yyleng = (int) (yy_cp - yy_bp); \ + yyleng = (yy_size_t) (yy_cp - yy_bp); \ (yy_hold_char) = *yy_cp; \ *yy_cp = '\0'; \ (yy_c_buf_p) = yy_cp; @@ -459,6 +460,7 @@ char *yytext; #line 2 "lexer.l" #include #include +#include #include // strerror #include #include "ASTDriver.h" @@ -472,8 +474,8 @@ char *yytext; #include #include #endif -#line 475 "lexer.cpp" -#line 20 "lexer.l" +#line 477 "lexer.cpp" +#line 21 "lexer.l" #if defined __clang__ # define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #endif @@ -542,18 +544,18 @@ char *yytext; #if defined GCC_VERSION && 900 <= GCC_VERSION # pragma GCC diagnostic ignored "-Wuseless-cast" #endif -#line 545 "lexer.cpp" +#line 547 "lexer.cpp" #define YY_NO_INPUT 1 -#line 93 "lexer.l" +#line 94 "lexer.l" // A number symbol corresponding to the value in S. adios2::detail::parser::symbol_type make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); -#line 551 "lexer.cpp" -#line 105 "lexer.l" +#line 553 "lexer.cpp" +#line 106 "lexer.l" // Code run each time a pattern is matched. # define YY_USER_ACTION loc.columns (yyleng); -#line 555 "lexer.cpp" -#line 556 "lexer.cpp" +#line 557 "lexer.cpp" +#line 558 "lexer.cpp" #define INITIAL 0 @@ -592,7 +594,7 @@ FILE *yyget_out ( void ); void yyset_out ( FILE * _out_str ); - int yyget_leng ( void ); + yy_size_t yyget_leng ( void ); char *yyget_text ( void ); @@ -659,7 +661,7 @@ static int input ( void ); if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \ { \ int c = '*'; \ - int n; \ + yy_size_t n; \ for ( n = 0; n < max_size && \ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \ buf[n] = (char) c; \ @@ -768,16 +770,16 @@ YY_DECL } { -#line 108 "lexer.l" +#line 109 "lexer.l" -#line 111 "lexer.l" +#line 112 "lexer.l" // A handy shortcut to the location held by the adios2::detail::ASTDriver. adios2::detail::location& loc = drv.location; // Code run each time yylex is called. loc.step (); -#line 780 "lexer.cpp" +#line 782 "lexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -832,88 +834,88 @@ YY_DECL case 1: YY_RULE_SETUP -#line 116 "lexer.l" +#line 117 "lexer.l" loc.step (); YY_BREAK case 2: /* rule 2 can match eol */ YY_RULE_SETUP -#line 117 "lexer.l" +#line 118 "lexer.l" loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); YY_BREAK case 3: YY_RULE_SETUP -#line 119 "lexer.l" +#line 120 "lexer.l" return adios2::detail::parser::make_ASSIGN (loc); YY_BREAK case 4: YY_RULE_SETUP -#line 120 "lexer.l" +#line 121 "lexer.l" return adios2::detail::parser::make_COMMA (loc); YY_BREAK case 5: YY_RULE_SETUP -#line 121 "lexer.l" +#line 122 "lexer.l" return adios2::detail::parser::make_COLON (loc); YY_BREAK case 6: YY_RULE_SETUP -#line 122 "lexer.l" +#line 123 "lexer.l" return adios2::detail::parser::make_L_PAREN (loc); YY_BREAK case 7: YY_RULE_SETUP -#line 123 "lexer.l" +#line 124 "lexer.l" return adios2::detail::parser::make_R_PAREN (loc); YY_BREAK case 8: YY_RULE_SETUP -#line 124 "lexer.l" +#line 125 "lexer.l" return adios2::detail::parser::make_L_BRACE (loc); YY_BREAK case 9: YY_RULE_SETUP -#line 125 "lexer.l" +#line 126 "lexer.l" return adios2::detail::parser::make_R_BRACE (loc); YY_BREAK case 10: YY_RULE_SETUP -#line 127 "lexer.l" +#line 128 "lexer.l" return make_INT (yytext, loc); YY_BREAK case 11: YY_RULE_SETUP -#line 128 "lexer.l" +#line 129 "lexer.l" return adios2::detail::parser::make_OPERATOR (yytext, loc); YY_BREAK case 12: YY_RULE_SETUP -#line 129 "lexer.l" +#line 130 "lexer.l" return adios2::detail::parser::make_IDENTIFIER (yytext, loc); YY_BREAK case 13: YY_RULE_SETUP -#line 130 "lexer.l" +#line 131 "lexer.l" return adios2::detail::parser::make_VARNAME (yytext, loc); YY_BREAK case 14: YY_RULE_SETUP -#line 131 "lexer.l" +#line 132 "lexer.l" { throw adios2::detail::parser::syntax_error (loc, "invalid character: " + std::string(yytext)); } YY_BREAK case YY_STATE_EOF(INITIAL): -#line 135 "lexer.l" +#line 136 "lexer.l" return adios2::detail::parser::make_YYEOF (loc); YY_BREAK case 15: YY_RULE_SETUP -#line 136 "lexer.l" +#line 137 "lexer.l" ECHO; YY_BREAK -#line 916 "lexer.cpp" +#line 918 "lexer.cpp" case YY_END_OF_BUFFER: { @@ -1099,7 +1101,7 @@ static int yy_get_next_buffer (void) else { - int num_to_read = + yy_size_t num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1; while ( num_to_read <= 0 ) @@ -1113,7 +1115,7 @@ static int yy_get_next_buffer (void) if ( b->yy_is_our_buffer ) { - int new_size = b->yy_buf_size * 2; + yy_size_t new_size = b->yy_buf_size * 2; if ( new_size <= 0 ) b->yy_buf_size += b->yy_buf_size / 8; @@ -1171,7 +1173,7 @@ static int yy_get_next_buffer (void) if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) { /* Extend the array by 50%, plus the number we really need. */ - int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); + yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1); YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc( (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size ); if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf ) @@ -1274,7 +1276,7 @@ static int yy_get_next_buffer (void) else { /* need more input */ - int offset = (int) ((yy_c_buf_p) - (yytext_ptr)); + yy_size_t offset = (yy_c_buf_p) - (yytext_ptr); ++(yy_c_buf_p); switch ( yy_get_next_buffer( ) ) @@ -1643,12 +1645,12 @@ YY_BUFFER_STATE yy_scan_string (const char * yystr ) * * @return the newly allocated buffer state object. */ -YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len ) +YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, yy_size_t _yybytes_len ) { YY_BUFFER_STATE b; char *buf; yy_size_t n; - int i; + yy_size_t i; /* Get memory for full buffer, including space for trailing EOB's. */ n = (yy_size_t) (_yybytes_len + 2); @@ -1690,7 +1692,7 @@ static void yynoreturn yy_fatal_error (const char* msg ) do \ { \ /* Undo effects of setting up yytext. */ \ - int yyless_macro_arg = (n); \ + yy_size_t yyless_macro_arg = (n); \ YY_LESS_LINENO(yyless_macro_arg);\ yytext[yyleng] = (yy_hold_char); \ (yy_c_buf_p) = yytext + yyless_macro_arg; \ @@ -1730,7 +1732,7 @@ FILE *yyget_out (void) /** Get the length of the current token. * */ -int yyget_leng (void) +yy_size_t yyget_leng (void) { return yyleng; } @@ -1880,7 +1882,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 136 "lexer.l" +#line 137 "lexer.l" adios2::detail::parser::symbol_type diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h index 68b7ab05e3..c03af3ed10 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h @@ -51,6 +51,7 @@ typedef int16_t flex_int16_t; typedef uint16_t flex_uint16_t; typedef int32_t flex_int32_t; typedef uint32_t flex_uint32_t; +typedef uint64_t flex_uint64_t; #else typedef signed char flex_int8_t; typedef short int flex_int16_t; @@ -130,7 +131,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; typedef size_t yy_size_t; #endif -extern int yyleng; +extern yy_size_t yyleng; extern FILE *yyin, *yyout; @@ -151,7 +152,7 @@ struct yy_buffer_state /* Number of characters read into yy_ch_buf, not including EOB * characters. */ - int yy_n_chars; + yy_size_t yy_n_chars; /* Whether we "own" the buffer - i.e., we know we created it, * and can realloc() it to grow it, and should free() it to @@ -195,7 +196,7 @@ void yypop_buffer_state ( void ); YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size ); YY_BUFFER_STATE yy_scan_string ( const char *yy_str ); -YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len ); +YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, yy_size_t len ); void *yyalloc ( yy_size_t ); void *yyrealloc ( void *, yy_size_t ); @@ -252,7 +253,7 @@ FILE *yyget_out ( void ); void yyset_out ( FILE * _out_str ); - int yyget_leng ( void ); + yy_size_t yyget_leng ( void ); char *yyget_text ( void ); @@ -469,9 +470,9 @@ extern int yylex (void); #undef yyTABLES_NAME #endif -#line 136 "lexer.l" +#line 137 "lexer.l" -#line 475 "lexer.h" +#line 476 "lexer.h" #undef yyIN_HEADER #endif /* yyHEADER_H */ From 1c4eee07ecafaa62375a2d0081c1574b1d1fe5d3 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Mon, 11 Mar 2024 14:52:03 -0400 Subject: [PATCH 31/46] Ignore IntelLLVM warning --- source/adios2/CMakeLists.txt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/adios2/CMakeLists.txt b/source/adios2/CMakeLists.txt index 1577ab136c..ff1645b4bb 100644 --- a/source/adios2/CMakeLists.txt +++ b/source/adios2/CMakeLists.txt @@ -160,6 +160,8 @@ if (ADIOS2_HAVE_Derived_Variable) SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp PROPERTIES COMPILE_FLAGS -Wno-sign-compare) elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel") SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/parser.cpp PROPERTIES COMPILE_FLAGS -Wno-unused-but-set-variable) + elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM") + SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/parser.cpp PROPERTIES COMPILE_FLAGS -Wno-unused-but-set-variable) elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") SET_SOURCE_FILES_PROPERTIES(toolkit/derived/Expression.cpp toolkit/derived/Function.cpp PROPERTIES COMPILE_FLAGS "/wd4005 /wd4065 /wd4267 -DYY_NO_UNISTD_H") endif() From ddd5a6aa10557bf24a25d5f693e90f3913519046 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Tue, 12 Mar 2024 14:24:32 -0400 Subject: [PATCH 32/46] Try init for ExpressionOperator --- source/adios2/toolkit/derived/Expression.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/source/adios2/toolkit/derived/Expression.h b/source/adios2/toolkit/derived/Expression.h index 6f60f1c262..9b3b29b5d5 100644 --- a/source/adios2/toolkit/derived/Expression.h +++ b/source/adios2/toolkit/derived/Expression.h @@ -23,7 +23,7 @@ namespace derived */ struct OpInfo { - adios2::detail::ExpressionOperator operation; + adios2::detail::ExpressionOperator operation = detail::ExpressionOperator::OP_NULL; std::vector> indices; double constant; }; From 69b251e33be5346e56b76faac87bc8ede743aea2 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Tue, 12 Mar 2024 15:21:52 -0400 Subject: [PATCH 33/46] Different tack --- source/adios2/toolkit/derived/Expression.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/source/adios2/toolkit/derived/Expression.h b/source/adios2/toolkit/derived/Expression.h index 9b3b29b5d5..2b6f8912a3 100644 --- a/source/adios2/toolkit/derived/Expression.h +++ b/source/adios2/toolkit/derived/Expression.h @@ -23,7 +23,7 @@ namespace derived */ struct OpInfo { - adios2::detail::ExpressionOperator operation = detail::ExpressionOperator::OP_NULL; + adios2::detail::ExpressionOperator operation; std::vector> indices; double constant; }; @@ -34,7 +34,7 @@ class ExpressionTree std::vector> sub_exprs; OpInfo detail; - ExpressionTree(){}; + ExpressionTree() : detail({adios2::detail::ExpressionOperator::OP_NULL, {}, 0}) {} ExpressionTree(adios2::detail::ExpressionOperator o) : detail({o, {}, 0}) {} ExpressionTree(adios2::detail::ExpressionOperator o, double c) : detail({o, {}, 0}) {} ExpressionTree(std::vector> indices) From b235bc1c2be02b70359574929f9d93d971b2eaaa Mon Sep 17 00:00:00 2001 From: lizdulac Date: Wed, 13 Mar 2024 13:45:58 -0400 Subject: [PATCH 34/46] Add ASTNode and ASTDriver destructors, and implicitly call parse function from ASTDriver construction. --- source/adios2/toolkit/derived/Expression.cpp | 5 +- .../toolkit/derived/parser/ASTDriver.cpp | 14 ++++ .../adios2/toolkit/derived/parser/ASTDriver.h | 6 +- .../adios2/toolkit/derived/parser/ASTNode.cpp | 9 +++ .../adios2/toolkit/derived/parser/ASTNode.h | 1 + source/adios2/toolkit/derived/parser/lexer.l | 3 +- .../derived/parser/pregen-source/lexer.cpp | 51 +++++++------- .../derived/parser/pregen-source/lexer.h | 2 +- .../derived/parser/pregen-source/location.hh | 4 +- .../derived/parser/pregen-source/parser.cpp | 68 +++++++++---------- .../derived/parser/pregen-source/parser.h | 6 +- 11 files changed, 95 insertions(+), 74 deletions(-) diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index 820161922e..81db7ccd15 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -81,9 +81,8 @@ namespace derived Expression::Expression(std::string string_exp) : m_Shape({0}), m_Start({0}), m_Count({0}), ExprString(string_exp) { - adios2::detail::ASTDriver drv; - adios2::detail::ASTNode *root_node = drv.parse(string_exp); - m_Expr = adios2::detail::ASTNode_to_ExpressionTree(root_node); + adios2::detail::ASTDriver drv(string_exp); + m_Expr = adios2::detail::ASTNode_to_ExpressionTree(drv.getAST()); } std::vector Expression::VariableNameList() { return m_Expr.VariableNameList(); } diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.cpp b/source/adios2/toolkit/derived/parser/ASTDriver.cpp index f21cc1fef9..8d9d456eb9 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.cpp +++ b/source/adios2/toolkit/derived/parser/ASTDriver.cpp @@ -9,6 +9,20 @@ using indx_type = std::vector>; ASTDriver::ASTDriver() {} +ASTDriver::ASTDriver(const std::string input) +{ + ASTDriver::parse(input); +} + +ASTDriver::~ASTDriver () +{ + while (holding.size() > 0) + { + delete holding.top(); + holding.pop(); + } +} + ASTNode *ASTDriver::getAST() { // TODO: check only one ASTNode remains in holding diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.h b/source/adios2/toolkit/derived/parser/ASTDriver.h index 2abe06dabd..c1f2855800 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.h +++ b/source/adios2/toolkit/derived/parser/ASTDriver.h @@ -22,9 +22,11 @@ class ASTDriver { public: ASTDriver(); + ASTDriver(const std::string input); + ~ASTDriver(); // Defined in lexer.l - ASTNode *parse(const std::string input); + void parse(const std::string input); ASTNode *getAST(); @@ -49,8 +51,6 @@ class ASTDriver adios2::detail::location location; private: - ASTNode *root; - // While parsing, holds ASTNodes until parent node is created // (since root node is created last from bottom up design) std::stack holding; diff --git a/source/adios2/toolkit/derived/parser/ASTNode.cpp b/source/adios2/toolkit/derived/parser/ASTNode.cpp index f5b74ee498..2c1fc4544a 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.cpp +++ b/source/adios2/toolkit/derived/parser/ASTNode.cpp @@ -27,6 +27,15 @@ ASTNode::ASTNode(std::string op, std::vector> i) indices = i; } +ASTNode::~ASTNode() +{ + for (ASTNode* sub_expr : sub_exprs) + { + delete sub_expr; + } + sub_exprs.clear(); +} + void ASTNode::set_num_subexprs(size_t n) { sub_exprs.resize(n); } void ASTNode::pushback_subexpr(ASTNode *subexpr) { sub_exprs.push_back(subexpr); } diff --git a/source/adios2/toolkit/derived/parser/ASTNode.h b/source/adios2/toolkit/derived/parser/ASTNode.h index 6ad8111b84..1d83ab5855 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.h +++ b/source/adios2/toolkit/derived/parser/ASTNode.h @@ -17,6 +17,7 @@ class ASTNode ASTNode(std::string, size_t); ASTNode(std::string, std::string); ASTNode(std::string, std::vector>); + ~ASTNode(); void set_num_subexprs(size_t); void pushback_subexpr(ASTNode *); diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index 11fbe9d75b..cc78406898 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -145,12 +145,11 @@ make_INT (const std::string &s, const adios2::detail::parser::location_type& loc return adios2::detail::parser::make_INT ((int) n, loc); } -adios2::detail::ASTNode* +void adios2::detail::ASTDriver::parse (const std::string input) { adios2::detail::parser parse (*this); yy_scan_string(input.c_str()); parse.set_debug_level (trace_parsing); parse (); - return getAST(); } diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index 02c931a5d9..23596819fc 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -456,8 +456,8 @@ int yy_flex_debug = 0; #define YY_MORE_ADJ 0 #define YY_RESTORE_YY_MORE_OFFSET char *yytext; -#line 1 "lexer.l" -#line 2 "lexer.l" +#line 1 "../lexer.l" +#line 2 "../lexer.l" #include #include #include @@ -475,7 +475,7 @@ char *yytext; #include #endif #line 477 "lexer.cpp" -#line 21 "lexer.l" +#line 21 "../lexer.l" #if defined __clang__ # define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #endif @@ -546,12 +546,12 @@ char *yytext; #endif #line 547 "lexer.cpp" #define YY_NO_INPUT 1 -#line 94 "lexer.l" +#line 94 "../lexer.l" // A number symbol corresponding to the value in S. adios2::detail::parser::symbol_type make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); #line 553 "lexer.cpp" -#line 106 "lexer.l" +#line 106 "../lexer.l" // Code run each time a pattern is matched. # define YY_USER_ACTION loc.columns (yyleng); #line 557 "lexer.cpp" @@ -770,10 +770,10 @@ YY_DECL } { -#line 109 "lexer.l" +#line 109 "../lexer.l" -#line 112 "lexer.l" +#line 112 "../lexer.l" // A handy shortcut to the location held by the adios2::detail::ASTDriver. adios2::detail::location& loc = drv.location; // Code run each time yylex is called. @@ -834,85 +834,85 @@ YY_DECL case 1: YY_RULE_SETUP -#line 117 "lexer.l" +#line 117 "../lexer.l" loc.step (); YY_BREAK case 2: /* rule 2 can match eol */ YY_RULE_SETUP -#line 118 "lexer.l" +#line 118 "../lexer.l" loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); YY_BREAK case 3: YY_RULE_SETUP -#line 120 "lexer.l" +#line 120 "../lexer.l" return adios2::detail::parser::make_ASSIGN (loc); YY_BREAK case 4: YY_RULE_SETUP -#line 121 "lexer.l" +#line 121 "../lexer.l" return adios2::detail::parser::make_COMMA (loc); YY_BREAK case 5: YY_RULE_SETUP -#line 122 "lexer.l" +#line 122 "../lexer.l" return adios2::detail::parser::make_COLON (loc); YY_BREAK case 6: YY_RULE_SETUP -#line 123 "lexer.l" +#line 123 "../lexer.l" return adios2::detail::parser::make_L_PAREN (loc); YY_BREAK case 7: YY_RULE_SETUP -#line 124 "lexer.l" +#line 124 "../lexer.l" return adios2::detail::parser::make_R_PAREN (loc); YY_BREAK case 8: YY_RULE_SETUP -#line 125 "lexer.l" +#line 125 "../lexer.l" return adios2::detail::parser::make_L_BRACE (loc); YY_BREAK case 9: YY_RULE_SETUP -#line 126 "lexer.l" +#line 126 "../lexer.l" return adios2::detail::parser::make_R_BRACE (loc); YY_BREAK case 10: YY_RULE_SETUP -#line 128 "lexer.l" +#line 128 "../lexer.l" return make_INT (yytext, loc); YY_BREAK case 11: YY_RULE_SETUP -#line 129 "lexer.l" +#line 129 "../lexer.l" return adios2::detail::parser::make_OPERATOR (yytext, loc); YY_BREAK case 12: YY_RULE_SETUP -#line 130 "lexer.l" +#line 130 "../lexer.l" return adios2::detail::parser::make_IDENTIFIER (yytext, loc); YY_BREAK case 13: YY_RULE_SETUP -#line 131 "lexer.l" +#line 131 "../lexer.l" return adios2::detail::parser::make_VARNAME (yytext, loc); YY_BREAK case 14: YY_RULE_SETUP -#line 132 "lexer.l" +#line 132 "../lexer.l" { throw adios2::detail::parser::syntax_error (loc, "invalid character: " + std::string(yytext)); } YY_BREAK case YY_STATE_EOF(INITIAL): -#line 136 "lexer.l" +#line 136 "../lexer.l" return adios2::detail::parser::make_YYEOF (loc); YY_BREAK case 15: YY_RULE_SETUP -#line 137 "lexer.l" +#line 137 "../lexer.l" ECHO; YY_BREAK #line 918 "lexer.cpp" @@ -1882,7 +1882,7 @@ void yyfree (void * ptr ) #define YYTABLES_NAME "yytables" -#line 137 "lexer.l" +#line 137 "../lexer.l" adios2::detail::parser::symbol_type @@ -1895,13 +1895,12 @@ make_INT (const std::string &s, const adios2::detail::parser::location_type& loc return adios2::detail::parser::make_INT ((int) n, loc); } -adios2::detail::ASTNode* +void adios2::detail::ASTDriver::parse (const std::string input) { adios2::detail::parser parse (*this); yy_scan_string(input.c_str()); parse.set_debug_level (trace_parsing); parse (); - return getAST(); } diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h index c03af3ed10..c83d2213a8 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h @@ -470,7 +470,7 @@ extern int yylex (void); #undef yyTABLES_NAME #endif -#line 137 "lexer.l" +#line 137 "../lexer.l" #line 476 "lexer.h" diff --git a/source/adios2/toolkit/derived/parser/pregen-source/location.hh b/source/adios2/toolkit/derived/parser/pregen-source/location.hh index 3669262d92..923c49c812 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/location.hh +++ b/source/adios2/toolkit/derived/parser/pregen-source/location.hh @@ -53,7 +53,7 @@ # endif # endif -#line 6 "..//parser.y" +#line 6 "../parser.y" namespace adios2 { namespace detail { #line 59 "location.hh" @@ -299,7 +299,7 @@ namespace adios2 { namespace detail { return ostr; } -#line 6 "..//parser.y" +#line 6 "../parser.y" } } // adios2::detail #line 305 "location.hh" diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp index fbc7a98f38..7d587ca18d 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp @@ -42,7 +42,7 @@ // Unqualified %code blocks. -#line 33 "..//parser.y" +#line 33 "../parser.y" #include "ASTDriver.h" #include "ASTNode.h" @@ -138,7 +138,7 @@ #define YYERROR goto yyerrorlab #define YYRECOVERING() (!!yyerrstatus_) -#line 6 "..//parser.y" +#line 6 "../parser.y" namespace adios2 { namespace detail { #line 144 "parser.cpp" @@ -638,181 +638,181 @@ namespace adios2 { namespace detail { switch (yyn) { case 2: // lines: assignment "\n" lines -#line 62 "..//parser.y" +#line 62 "../parser.y" {} #line 644 "parser.cpp" break; case 3: // lines: exp -#line 63 "..//parser.y" +#line 63 "../parser.y" {} #line 650 "parser.cpp" break; case 4: // assignment: "identifier" "=" VARNAME -#line 67 "..//parser.y" +#line 67 "../parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 656 "parser.cpp" break; case 5: // assignment: "identifier" "=" "identifier" -#line 68 "..//parser.y" +#line 68 "../parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 662 "parser.cpp" break; case 6: // assignment: "identifier" "=" VARNAME "[" indices_list "]" -#line 69 "..//parser.y" +#line 69 "../parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 668 "parser.cpp" break; case 7: // assignment: "identifier" "=" "identifier" "[" indices_list "]" -#line 70 "..//parser.y" +#line 70 "../parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 674 "parser.cpp" break; case 8: // exp: "number" -#line 74 "..//parser.y" +#line 74 "../parser.y" { } #line 680 "parser.cpp" break; case 9: // exp: exp OPERATOR exp -#line 75 "..//parser.y" +#line 75 "../parser.y" { drv.createNode(yystack_[1].value.as < std::string > (), 2); } #line 686 "parser.cpp" break; case 10: // exp: "(" exp ")" -#line 76 "..//parser.y" +#line 76 "../parser.y" { } #line 692 "parser.cpp" break; case 11: // exp: "identifier" "(" list ")" -#line 77 "..//parser.y" +#line 77 "../parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } #line 698 "parser.cpp" break; case 12: // exp: "identifier" "[" indices_list "]" -#line 78 "..//parser.y" +#line 78 "../parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 704 "parser.cpp" break; case 13: // exp: "identifier" -#line 79 "..//parser.y" +#line 79 "../parser.y" { drv.createNode(yystack_[0].value.as < std::string > ()); } #line 710 "parser.cpp" break; case 14: // indices_list: %empty -#line 84 "..//parser.y" +#line 84 "../parser.y" { yylhs.value.as < std::vector> > () = {}; } #line 716 "parser.cpp" break; case 15: // indices_list: indices_list "," index -#line 85 "..//parser.y" +#line 85 "../parser.y" { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } #line 722 "parser.cpp" break; case 16: // indices_list: index -#line 86 "..//parser.y" +#line 86 "../parser.y" { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } #line 728 "parser.cpp" break; case 17: // index: %empty -#line 90 "..//parser.y" +#line 90 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } #line 734 "parser.cpp" break; case 18: // index: "number" ":" "number" ":" "number" -#line 91 "..//parser.y" +#line 91 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 740 "parser.cpp" break; case 19: // index: ":" "number" ":" "number" -#line 92 "..//parser.y" +#line 92 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 746 "parser.cpp" break; case 20: // index: "number" ":" ":" "number" -#line 93 "..//parser.y" +#line 93 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } #line 752 "parser.cpp" break; case 21: // index: "number" ":" "number" ":" -#line 94 "..//parser.y" +#line 94 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } #line 758 "parser.cpp" break; case 22: // index: "number" ":" "number" -#line 95 "..//parser.y" +#line 95 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 764 "parser.cpp" break; case 23: // index: ":" ":" "number" -#line 96 "..//parser.y" +#line 96 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } #line 770 "parser.cpp" break; case 24: // index: ":" "number" ":" -#line 97 "..//parser.y" +#line 97 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } #line 776 "parser.cpp" break; case 25: // index: ":" "number" -#line 98 "..//parser.y" +#line 98 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } #line 782 "parser.cpp" break; case 26: // index: "number" ":" ":" -#line 99 "..//parser.y" +#line 99 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } #line 788 "parser.cpp" break; case 27: // index: "number" ":" -#line 100 "..//parser.y" +#line 100 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } #line 794 "parser.cpp" break; case 28: // index: "number" -#line 101 "..//parser.y" +#line 101 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 800 "parser.cpp" break; case 29: // list: %empty -#line 105 "..//parser.y" +#line 105 "../parser.y" { yylhs.value.as < int > () = 0; } #line 806 "parser.cpp" break; case 30: // list: exp "," list -#line 106 "..//parser.y" +#line 106 "../parser.y" { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } #line 812 "parser.cpp" break; case 31: // list: exp -#line 107 "..//parser.y" +#line 107 "../parser.y" { yylhs.value.as < int > () = 1; } #line 818 "parser.cpp" break; @@ -1400,11 +1400,11 @@ namespace adios2 { namespace detail { #endif // YYDEBUG -#line 6 "..//parser.y" +#line 6 "../parser.y" } } // adios2::detail #line 1406 "parser.cpp" -#line 108 "..//parser.y" +#line 108 "../parser.y" void diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/parser.h index b69f5d252c..dc3996fa2d 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.h @@ -45,7 +45,7 @@ #ifndef YY_YY_PARSER_H_INCLUDED # define YY_YY_PARSER_H_INCLUDED // "%code requires" blocks. -#line 11 "..//parser.y" +#line 11 "../parser.y" #include #include @@ -197,7 +197,7 @@ # define YYDEBUG 1 #endif -#line 6 "..//parser.y" +#line 6 "../parser.y" namespace adios2 { namespace detail { #line 203 "parser.h" @@ -1616,7 +1616,7 @@ switch (yykind) } -#line 6 "..//parser.y" +#line 6 "../parser.y" } } // adios2::detail #line 1622 "parser.h" From 947d4660feccdbee09d922756ce20bb750181848 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Wed, 13 Mar 2024 13:55:56 -0400 Subject: [PATCH 35/46] formatting --- source/adios2/toolkit/derived/parser/ASTDriver.cpp | 7 ++----- source/adios2/toolkit/derived/parser/ASTNode.cpp | 2 +- 2 files changed, 3 insertions(+), 6 deletions(-) diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.cpp b/source/adios2/toolkit/derived/parser/ASTDriver.cpp index 8d9d456eb9..53871e0db8 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.cpp +++ b/source/adios2/toolkit/derived/parser/ASTDriver.cpp @@ -9,12 +9,9 @@ using indx_type = std::vector>; ASTDriver::ASTDriver() {} -ASTDriver::ASTDriver(const std::string input) -{ - ASTDriver::parse(input); -} +ASTDriver::ASTDriver(const std::string input) { ASTDriver::parse(input); } -ASTDriver::~ASTDriver () +ASTDriver::~ASTDriver() { while (holding.size() > 0) { diff --git a/source/adios2/toolkit/derived/parser/ASTNode.cpp b/source/adios2/toolkit/derived/parser/ASTNode.cpp index 2c1fc4544a..3563a4c78f 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.cpp +++ b/source/adios2/toolkit/derived/parser/ASTNode.cpp @@ -29,7 +29,7 @@ ASTNode::ASTNode(std::string op, std::vector> i) ASTNode::~ASTNode() { - for (ASTNode* sub_expr : sub_exprs) + for (ASTNode *sub_expr : sub_exprs) { delete sub_expr; } From 30f7cc3add85c12f835d85f06936664515fb900f Mon Sep 17 00:00:00 2001 From: lizdulac Date: Thu, 14 Mar 2024 11:32:56 -0400 Subject: [PATCH 36/46] MinVarInfo unique_ptrs --- source/adios2/core/VariableDerived.cpp | 18 +++++++++--------- source/adios2/core/VariableDerived.h | 2 +- source/adios2/engine/bp5/BP5Writer.cpp | 16 ++++++++++------ 3 files changed, 20 insertions(+), 16 deletions(-) diff --git a/source/adios2/core/VariableDerived.cpp b/source/adios2/core/VariableDerived.cpp index c06a7265d6..07819bf00e 100644 --- a/source/adios2/core/VariableDerived.cpp +++ b/source/adios2/core/VariableDerived.cpp @@ -27,15 +27,15 @@ void VariableDerived::UpdateExprDim(std::map> -VariableDerived::ApplyExpression(std::map NameToMVI) +VariableDerived::ApplyExpression(std::map> &NameToMVI) { size_t numBlocks = 0; // check that all variables have the same number of blocks - for (auto variable : NameToMVI) + for (const auto &variable : NameToMVI) { if (numBlocks == 0) - numBlocks = variable.second.BlocksInfo.size(); - if (numBlocks != variable.second.BlocksInfo.size()) + numBlocks = variable.second->BlocksInfo.size(); + if (numBlocks != variable.second->BlocksInfo.size()) helper::Throw("Core", "VariableDerived", "ApplyExpression", " variables do not have the same number of blocks " " in computing the derived variable " + @@ -44,7 +44,7 @@ VariableDerived::ApplyExpression(std::map NameToMVI) std::map> inputData; // create the map between variable name and DerivedData object - for (auto variable : NameToMVI) + for (const auto &variable : NameToMVI) { // add the dimensions of all blocks into a vector std::vector varData; @@ -52,13 +52,13 @@ VariableDerived::ApplyExpression(std::map NameToMVI) { Dims start; Dims count; - for (int d = 0; d < variable.second.Dims; d++) + for (int d = 0; d < variable.second->Dims; d++) { - start.push_back(variable.second.BlocksInfo[i].Start[d]); - count.push_back(variable.second.BlocksInfo[i].Count[d]); + start.push_back(variable.second->BlocksInfo[i].Start[d]); + count.push_back(variable.second->BlocksInfo[i].Count[d]); } varData.push_back(adios2::derived::DerivedData( - {variable.second.BlocksInfo[i].BufferP, start, count})); + {variable.second->BlocksInfo[i].BufferP, start, count})); } inputData.insert({variable.first, varData}); } diff --git a/source/adios2/core/VariableDerived.h b/source/adios2/core/VariableDerived.h index 2ff9eb3903..cc7bf8cbf2 100644 --- a/source/adios2/core/VariableDerived.h +++ b/source/adios2/core/VariableDerived.h @@ -32,7 +32,7 @@ class VariableDerived : public VariableBase ApplyExpression(std::map> NameToData, std::map> NameToDims); std::vector> - ApplyExpression(std::map mvi); + ApplyExpression(std::map> &mvi); }; } // end namespace core diff --git a/source/adios2/engine/bp5/BP5Writer.cpp b/source/adios2/engine/bp5/BP5Writer.cpp index 78c0646e6b..0bc20c19b4 100644 --- a/source/adios2/engine/bp5/BP5Writer.cpp +++ b/source/adios2/engine/bp5/BP5Writer.cpp @@ -516,7 +516,7 @@ void BP5Writer::ComputeDerivedVariables() auto derivedVar = dynamic_cast((*it).second.get()); std::vector varList = derivedVar->VariableNameList(); // to create a mapping between variable name and the varInfo (dim and data pointer) - std::map nameToVarInfo; + std::map> nameToVarInfo; bool computeDerived = true; for (auto varName : varList) { @@ -536,7 +536,7 @@ void BP5Writer::ComputeDerivedVariables() std::cout << " .. skip derived variable " << (*it).second->m_Name << std::endl; break; } - nameToVarInfo.insert({varName, *mvi}); + nameToVarInfo.insert({varName, std::unique_ptr(mvi)}); } // skip computing derived variables if it contains variables that are not written this step if (!computeDerived) @@ -881,7 +881,8 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) switch (recordID) { - case IndexRecord::WriterMapRecord: { + case IndexRecord::WriterMapRecord: + { m_AppendWriterCount = (uint32_t)helper::ReadValue(buffer, position, IsLittleEndian); m_AppendAggregatorCount = @@ -896,7 +897,8 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) position += m_AppendWriterCount * sizeof(uint64_t); break; } - case IndexRecord::StepRecord: { + case IndexRecord::StepRecord: + { position += 2 * sizeof(uint64_t); // MetadataPos, MetadataSize const uint64_t FlushCount = helper::ReadValue(buffer, position, IsLittleEndian); @@ -965,7 +967,8 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) switch (recordID) { - case IndexRecord::WriterMapRecord: { + case IndexRecord::WriterMapRecord: + { m_AppendWriterCount = (uint32_t)helper::ReadValue(buffer, position, IsLittleEndian); m_AppendAggregatorCount = @@ -983,7 +986,8 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) } break; } - case IndexRecord::StepRecord: { + case IndexRecord::StepRecord: + { m_AppendMetadataIndexPos = position - sizeof(unsigned char) - sizeof(uint64_t); // pos of RecordID const uint64_t MetadataPos = From 16256cb935638ceb11585ab92853eca44aaf8f91 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Thu, 14 Mar 2024 11:40:08 -0400 Subject: [PATCH 37/46] formatting (again) --- source/adios2/engine/bp5/BP5Writer.cpp | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/source/adios2/engine/bp5/BP5Writer.cpp b/source/adios2/engine/bp5/BP5Writer.cpp index 0bc20c19b4..ff1889577e 100644 --- a/source/adios2/engine/bp5/BP5Writer.cpp +++ b/source/adios2/engine/bp5/BP5Writer.cpp @@ -881,8 +881,7 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) switch (recordID) { - case IndexRecord::WriterMapRecord: - { + case IndexRecord::WriterMapRecord: { m_AppendWriterCount = (uint32_t)helper::ReadValue(buffer, position, IsLittleEndian); m_AppendAggregatorCount = @@ -897,8 +896,7 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) position += m_AppendWriterCount * sizeof(uint64_t); break; } - case IndexRecord::StepRecord: - { + case IndexRecord::StepRecord: { position += 2 * sizeof(uint64_t); // MetadataPos, MetadataSize const uint64_t FlushCount = helper::ReadValue(buffer, position, IsLittleEndian); @@ -967,8 +965,7 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) switch (recordID) { - case IndexRecord::WriterMapRecord: - { + case IndexRecord::WriterMapRecord: { m_AppendWriterCount = (uint32_t)helper::ReadValue(buffer, position, IsLittleEndian); m_AppendAggregatorCount = @@ -986,8 +983,7 @@ uint64_t BP5Writer::CountStepsInMetadataIndex(format::BufferSTL &bufferSTL) } break; } - case IndexRecord::StepRecord: - { + case IndexRecord::StepRecord: { m_AppendMetadataIndexPos = position - sizeof(unsigned char) - sizeof(uint64_t); // pos of RecordID const uint64_t MetadataPos = From b329e9f9f0c8eb4e42f7e6b13ffe22c2cd069733 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Thu, 14 Mar 2024 12:42:55 -0400 Subject: [PATCH 38/46] Free ExprStr --- source/adios2/toolkit/format/bp5/BP5Deserializer.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/source/adios2/toolkit/format/bp5/BP5Deserializer.cpp b/source/adios2/toolkit/format/bp5/BP5Deserializer.cpp index 0e7574a17c..9c1a127408 100644 --- a/source/adios2/toolkit/format/bp5/BP5Deserializer.cpp +++ b/source/adios2/toolkit/format/bp5/BP5Deserializer.cpp @@ -1994,6 +1994,8 @@ BP5Deserializer::~BP5Deserializer() m_Engine->m_IO.RemoveVariable(VarRec.second->VarName); free(VarRec.second->VarName); + if (VarRec.second->ExprStr) + free(VarRec.second->ExprStr); if (VarRec.second->Operator) free(VarRec.second->Operator); if (VarRec.second->Def) From 3d22e5f8f643a8f1d3efdd44828ebd8e0c5d522b Mon Sep 17 00:00:00 2001 From: lizdulac Date: Fri, 15 Mar 2024 11:56:46 -0400 Subject: [PATCH 39/46] Change expression assignment character from : to = --- testing/adios2/bindings/fortran/TestBPWriteTypes.F90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 index 7cb02991e0..54f8ca3dd7 100644 --- a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 +++ b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 @@ -166,7 +166,7 @@ program TestBPWriteTypes ! derived variable call adios2_define_derived_variable(derived_variable, ioWrite, "derived/magnitude_of_var_R64", & - "x:var_R64 y:var_R64 z:var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) + "x=var_R64 y=var_R64 z=var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) do i=1,13 if( variables(i)%valid .eqv. .false. ) stop 'Invalid adios2_define_variable' From 1082b80cc75aa135324a741ff14b66b49fce5272 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Fri, 15 Mar 2024 13:04:24 -0400 Subject: [PATCH 40/46] Grammar accepts any blank space between alias definitions --- source/adios2/toolkit/derived/parser/lexer.l | 2 +- source/adios2/toolkit/derived/parser/parser.y | 5 +- .../derived/parser/pregen-source/lexer.cpp | 2 +- .../derived/parser/pregen-source/parser.cpp | 144 +++++++++--------- .../derived/parser/pregen-source/parser.h | 55 +++---- 5 files changed, 95 insertions(+), 113 deletions(-) diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index cc78406898..566e4a41c7 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -114,7 +114,7 @@ blank [ \t\r] loc.step (); %} {blank}+ loc.step (); -\n+ loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); +\n+ loc.lines (yyleng); loc.step (); "=" return adios2::detail::parser::make_ASSIGN (loc); "," return adios2::detail::parser::make_COMMA (loc); diff --git a/source/adios2/toolkit/derived/parser/parser.y b/source/adios2/toolkit/derived/parser/parser.y index 50dfc7669e..a258b34bc1 100644 --- a/source/adios2/toolkit/derived/parser/parser.y +++ b/source/adios2/toolkit/derived/parser/parser.y @@ -44,7 +44,6 @@ R_PAREN ")" L_BRACE "[" R_BRACE "]" - ENDL "\n" ; %token OPERATOR @@ -54,12 +53,12 @@ %nterm list %nterm >> indices_list %nterm > index -%left OPERATOR ENDL +%left OPERATOR %% %start lines; lines: - assignment ENDL lines {} + assignment lines {} | exp {} ; diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index 23596819fc..11c2e6b66a 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -841,7 +841,7 @@ case 2: /* rule 2 can match eol */ YY_RULE_SETUP #line 118 "../lexer.l" -loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); +loc.lines (yyleng); loc.step (); YY_BREAK case 3: YY_RULE_SETUP diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp index 7d587ca18d..e11401c54d 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp @@ -637,182 +637,182 @@ namespace adios2 { namespace detail { { switch (yyn) { - case 2: // lines: assignment "\n" lines -#line 62 "../parser.y" - {} + case 2: // lines: assignment lines +#line 61 "../parser.y" + {} #line 644 "parser.cpp" break; case 3: // lines: exp -#line 63 "../parser.y" +#line 62 "../parser.y" {} #line 650 "parser.cpp" break; case 4: // assignment: "identifier" "=" VARNAME -#line 67 "../parser.y" +#line 66 "../parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 656 "parser.cpp" break; case 5: // assignment: "identifier" "=" "identifier" -#line 68 "../parser.y" +#line 67 "../parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 662 "parser.cpp" break; case 6: // assignment: "identifier" "=" VARNAME "[" indices_list "]" -#line 69 "../parser.y" +#line 68 "../parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 668 "parser.cpp" break; case 7: // assignment: "identifier" "=" "identifier" "[" indices_list "]" -#line 70 "../parser.y" +#line 69 "../parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 674 "parser.cpp" break; case 8: // exp: "number" -#line 74 "../parser.y" +#line 73 "../parser.y" { } #line 680 "parser.cpp" break; case 9: // exp: exp OPERATOR exp -#line 75 "../parser.y" +#line 74 "../parser.y" { drv.createNode(yystack_[1].value.as < std::string > (), 2); } #line 686 "parser.cpp" break; case 10: // exp: "(" exp ")" -#line 76 "../parser.y" +#line 75 "../parser.y" { } #line 692 "parser.cpp" break; case 11: // exp: "identifier" "(" list ")" -#line 77 "../parser.y" +#line 76 "../parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } #line 698 "parser.cpp" break; case 12: // exp: "identifier" "[" indices_list "]" -#line 78 "../parser.y" +#line 77 "../parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 704 "parser.cpp" break; case 13: // exp: "identifier" -#line 79 "../parser.y" +#line 78 "../parser.y" { drv.createNode(yystack_[0].value.as < std::string > ()); } #line 710 "parser.cpp" break; case 14: // indices_list: %empty -#line 84 "../parser.y" +#line 83 "../parser.y" { yylhs.value.as < std::vector> > () = {}; } #line 716 "parser.cpp" break; case 15: // indices_list: indices_list "," index -#line 85 "../parser.y" +#line 84 "../parser.y" { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } #line 722 "parser.cpp" break; case 16: // indices_list: index -#line 86 "../parser.y" +#line 85 "../parser.y" { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } #line 728 "parser.cpp" break; case 17: // index: %empty -#line 90 "../parser.y" +#line 89 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } #line 734 "parser.cpp" break; case 18: // index: "number" ":" "number" ":" "number" -#line 91 "../parser.y" +#line 90 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 740 "parser.cpp" break; case 19: // index: ":" "number" ":" "number" -#line 92 "../parser.y" +#line 91 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 746 "parser.cpp" break; case 20: // index: "number" ":" ":" "number" -#line 93 "../parser.y" +#line 92 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } #line 752 "parser.cpp" break; case 21: // index: "number" ":" "number" ":" -#line 94 "../parser.y" +#line 93 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } #line 758 "parser.cpp" break; case 22: // index: "number" ":" "number" -#line 95 "../parser.y" +#line 94 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 764 "parser.cpp" break; case 23: // index: ":" ":" "number" -#line 96 "../parser.y" +#line 95 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } #line 770 "parser.cpp" break; case 24: // index: ":" "number" ":" -#line 97 "../parser.y" +#line 96 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } #line 776 "parser.cpp" break; case 25: // index: ":" "number" -#line 98 "../parser.y" +#line 97 "../parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } #line 782 "parser.cpp" break; case 26: // index: "number" ":" ":" -#line 99 "../parser.y" +#line 98 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } #line 788 "parser.cpp" break; case 27: // index: "number" ":" -#line 100 "../parser.y" +#line 99 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } #line 794 "parser.cpp" break; case 28: // index: "number" -#line 101 "../parser.y" +#line 100 "../parser.y" { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 800 "parser.cpp" break; case 29: // list: %empty -#line 105 "../parser.y" +#line 104 "../parser.y" { yylhs.value.as < int > () = 0; } #line 806 "parser.cpp" break; case 30: // list: exp "," list -#line 106 "../parser.y" +#line 105 "../parser.y" { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } #line 812 "parser.cpp" break; case 31: // list: exp -#line 107 "../parser.y" +#line 106 "../parser.y" { yylhs.value.as < int > () = 1; } #line 818 "parser.cpp" break; @@ -1003,8 +1003,8 @@ namespace adios2 { namespace detail { static const char *const yy_sname[] = { "end of file", "error", "invalid token", "=", ",", ":", "(", ")", "[", - "]", "\n", "OPERATOR", "identifier", "VARNAME", "number", "$accept", - "lines", "assignment", "exp", "indices_list", "index", "list", YY_NULLPTR + "]", "OPERATOR", "identifier", "VARNAME", "number", "$accept", "lines", + "assignment", "exp", "indices_list", "index", "list", YY_NULLPTR }; return yy_sname[yysymbol]; } @@ -1273,34 +1273,34 @@ namespace adios2 { namespace detail { } - const signed char parser::yypact_ninf_ = -21; + const signed char parser::yypact_ninf_ = -7; const signed char parser::yytable_ninf_ = -1; const signed char parser::yypact_[] = { - 2, 9, 22, -21, 19, 10, 15, 32, 11, -8, - 9, -4, -21, 2, 9, -21, 31, 33, 13, 26, - -3, 30, 25, -21, -21, -21, -4, -4, 9, -21, - 29, 37, -2, -4, -21, 27, 28, -21, -21, 34, - 35, 39, -21, -21, -21, -21, -21, 36, -21 + 6, 9, 22, -7, 5, 6, 13, 27, -6, -4, + 9, -3, -7, -7, 9, -7, 30, 31, 14, 24, + -2, 35, 12, -7, -7, -3, -3, 9, -7, 28, + 37, 1, -3, -7, 23, 25, -7, -7, 32, 33, + 38, -7, -7, -7, -7, -7, 34, -7 }; const signed char parser::yydefact_[] = { 0, 0, 13, 8, 0, 0, 3, 13, 0, 0, - 29, 14, 1, 0, 0, 10, 5, 4, 31, 0, - 0, 28, 0, 16, 2, 9, 14, 14, 29, 11, - 0, 25, 27, 17, 12, 0, 0, 30, 23, 24, - 26, 22, 15, 7, 6, 19, 20, 21, 18 + 29, 14, 1, 2, 0, 10, 5, 4, 31, 0, + 0, 28, 0, 16, 9, 14, 14, 29, 11, 0, + 25, 27, 17, 12, 0, 0, 30, 23, 24, 26, + 22, 15, 7, 6, 19, 20, 21, 18 }; const signed char parser::yypgoto_[] = { - -21, 38, -21, -1, -20, 12, 18 + -7, 39, -7, -1, 11, 16, 26 }; const signed char @@ -1312,48 +1312,48 @@ namespace adios2 { namespace detail { const signed char parser::yytable_[] = { - 8, 20, 30, 40, 16, 17, 35, 36, 1, 18, - 21, 31, 41, 25, 2, 1, 3, 28, 15, 12, - 13, 7, 14, 3, 14, 9, 14, 18, 10, 33, - 11, 33, 33, 29, 34, 32, 43, 44, 10, 26, - 11, 27, 39, 38, 47, 42, 37, 0, 45, 46, - 48, 24 + 8, 15, 20, 29, 14, 12, 39, 16, 17, 18, + 21, 30, 1, 24, 40, 1, 32, 2, 27, 3, + 7, 33, 3, 14, 14, 9, 18, 32, 10, 32, + 11, 28, 42, 10, 43, 11, 34, 35, 25, 26, + 31, 37, 38, 46, 13, 44, 45, 47, 41, 0, + 0, 0, 0, 36 }; const signed char parser::yycheck_[] = { - 1, 5, 5, 5, 12, 13, 26, 27, 6, 10, - 14, 14, 14, 14, 12, 6, 14, 4, 7, 0, - 10, 12, 11, 14, 11, 3, 11, 28, 6, 4, - 8, 4, 4, 7, 9, 5, 9, 9, 6, 8, - 8, 8, 5, 14, 5, 33, 28, -1, 14, 14, - 14, 13 + 1, 7, 5, 5, 10, 0, 5, 11, 12, 10, + 13, 13, 6, 14, 13, 6, 4, 11, 4, 13, + 11, 9, 13, 10, 10, 3, 27, 4, 6, 4, + 8, 7, 9, 6, 9, 8, 25, 26, 8, 8, + 5, 13, 5, 5, 5, 13, 13, 13, 32, -1, + -1, -1, -1, 27 }; const signed char parser::yystos_[] = { - 0, 6, 12, 14, 16, 17, 18, 12, 18, 3, - 6, 8, 0, 10, 11, 7, 12, 13, 18, 21, - 5, 14, 19, 20, 16, 18, 8, 8, 4, 7, - 5, 14, 5, 4, 9, 19, 19, 21, 14, 5, - 5, 14, 20, 9, 9, 14, 14, 5, 14 + 0, 6, 11, 13, 15, 16, 17, 11, 17, 3, + 6, 8, 0, 15, 10, 7, 11, 12, 17, 20, + 5, 13, 18, 19, 17, 8, 8, 4, 7, 5, + 13, 5, 4, 9, 18, 18, 20, 13, 5, 5, + 13, 19, 9, 9, 13, 13, 5, 13 }; const signed char parser::yyr1_[] = { - 0, 15, 16, 16, 17, 17, 17, 17, 18, 18, - 18, 18, 18, 18, 19, 19, 19, 20, 20, 20, - 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, - 21, 21 + 0, 14, 15, 15, 16, 16, 16, 16, 17, 17, + 17, 17, 17, 17, 18, 18, 18, 19, 19, 19, + 19, 19, 19, 19, 19, 19, 19, 19, 19, 20, + 20, 20 }; const signed char parser::yyr2_[] = { - 0, 2, 3, 1, 3, 3, 6, 6, 1, 3, + 0, 2, 2, 1, 3, 3, 6, 6, 1, 3, 3, 4, 4, 1, 0, 3, 1, 0, 5, 4, 4, 4, 3, 3, 3, 2, 3, 2, 1, 0, 3, 1 @@ -1366,10 +1366,10 @@ namespace adios2 { namespace detail { const signed char parser::yyrline_[] = { - 0, 62, 62, 63, 67, 68, 69, 70, 74, 75, - 76, 77, 78, 79, 84, 85, 86, 90, 91, 92, - 93, 94, 95, 96, 97, 98, 99, 100, 101, 105, - 106, 107 + 0, 61, 61, 62, 66, 67, 68, 69, 73, 74, + 75, 76, 77, 78, 83, 84, 85, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99, 100, 104, + 105, 106 }; void @@ -1404,7 +1404,7 @@ namespace adios2 { namespace detail { } } // adios2::detail #line 1406 "parser.cpp" -#line 108 "../parser.y" +#line 107 "../parser.y" void diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.h b/source/adios2/toolkit/derived/parser/pregen-source/parser.h index dc3996fa2d..819381e379 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.h @@ -491,11 +491,10 @@ namespace adios2 { namespace detail { TOK_R_PAREN = 7, // ")" TOK_L_BRACE = 8, // "[" TOK_R_BRACE = 9, // "]" - TOK_ENDL = 10, // "\n" - TOK_OPERATOR = 11, // OPERATOR - TOK_IDENTIFIER = 12, // "identifier" - TOK_VARNAME = 13, // VARNAME - TOK_INT = 14 // "number" + TOK_OPERATOR = 10, // OPERATOR + TOK_IDENTIFIER = 11, // "identifier" + TOK_VARNAME = 12, // VARNAME + TOK_INT = 13 // "number" }; /// Backward compatibility alias (Bison 3.6). typedef token_kind_type yytokentype; @@ -512,7 +511,7 @@ namespace adios2 { namespace detail { { enum symbol_kind_type { - YYNTOKENS = 15, ///< Number of tokens. + YYNTOKENS = 14, ///< Number of tokens. S_YYEMPTY = -2, S_YYEOF = 0, // "end of file" S_YYerror = 1, // error @@ -524,18 +523,17 @@ namespace adios2 { namespace detail { S_R_PAREN = 7, // ")" S_L_BRACE = 8, // "[" S_R_BRACE = 9, // "]" - S_ENDL = 10, // "\n" - S_OPERATOR = 11, // OPERATOR - S_IDENTIFIER = 12, // "identifier" - S_VARNAME = 13, // VARNAME - S_INT = 14, // "number" - S_YYACCEPT = 15, // $accept - S_lines = 16, // lines - S_assignment = 17, // assignment - S_exp = 18, // exp - S_indices_list = 19, // indices_list - S_index = 20, // index - S_list = 21 // list + S_OPERATOR = 10, // OPERATOR + S_IDENTIFIER = 11, // "identifier" + S_VARNAME = 12, // VARNAME + S_INT = 13, // "number" + S_YYACCEPT = 14, // $accept + S_lines = 15, // lines + S_assignment = 16, // assignment + S_exp = 17, // exp + S_indices_list = 18, // indices_list + S_index = 19, // index + S_list = 20 // list }; }; @@ -811,7 +809,7 @@ switch (yykind) { #if !defined _MSC_VER || defined __clang__ YY_ASSERT (tok == token::TOK_YYEOF - || (token::TOK_YYerror <= tok && tok <= token::TOK_ENDL)); + || (token::TOK_YYerror <= tok && tok <= token::TOK_R_BRACE)); #endif } #if 201103L <= YY_CPLUSPLUS @@ -1036,21 +1034,6 @@ switch (yykind) return symbol_type (token::TOK_R_BRACE, l); } #endif -#if 201103L <= YY_CPLUSPLUS - static - symbol_type - make_ENDL (location_type l) - { - return symbol_type (token::TOK_ENDL, std::move (l)); - } -#else - static - symbol_type - make_ENDL (const location_type& l) - { - return symbol_type (token::TOK_ENDL, l); - } -#endif #if 201103L <= YY_CPLUSPLUS static symbol_type @@ -1455,7 +1438,7 @@ switch (yykind) /// Constants. enum { - yylast_ = 51, ///< Last index in yytable_. + yylast_ = 53, ///< Last index in yytable_. yynnts_ = 7, ///< Number of nonterminal symbols. yyfinal_ = 12 ///< Termination state number. }; @@ -1618,7 +1601,7 @@ switch (yykind) #line 6 "../parser.y" } } // adios2::detail -#line 1622 "parser.h" +#line 1605 "parser.h" From 6d795bdc1c5b057f1fd4ddb459b84c8b59f56413 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 17 Mar 2024 08:48:11 -0400 Subject: [PATCH 41/46] Restore Derived Variable status to defaulting to off --- CMakeLists.txt | 2 +- .../bindings/fortran/TestBPWriteTypes.F90 | 281 ++++++++++++++---- 2 files changed, 225 insertions(+), 58 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 8ee0331e55..8511e152bf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -185,7 +185,7 @@ adios_option(Sodium "Enable support for Sodium for encryption" AUTO) adios_option(Catalyst "Enable support for in situ visualization plugin using ParaView Catalyst" AUTO) adios_option(Campaign "Enable support for Campaigns (requires SQLite3 and ZLIB)" OFF) adios_option(AWSSDK "Enable support for S3 compatible storage using AWS SDK's S3 module" OFF) -adios_option(Derived_Variable "Enable support for derived variables" ON) +adios_option(Derived_Variable "Enable support for derived variables" OFF) adios_option(PIP "Enable support for pip packaging" OFF) option(ADIOS2_Blosc2_PREFER_SHARED "Prefer shared Blosc2 libraries" ON) diff --git a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 index 54f8ca3dd7..0be6110352 100644 --- a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 +++ b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 @@ -51,14 +51,26 @@ program TestBPWriteTypes start_dims(1) = irank*inx count_dims(1) = inx - if( adios%valid .eqv. .true. ) stop 'Invalid adios default' - if( ioWrite%valid .eqv. .true. ) stop 'Invalid io default' + if( adios%valid .eqv. .true. ) then + write(*,*) 'Invalid adios default' + stop 1 + end if + if( ioWrite%valid .eqv. .true. ) then + write(*,*) 'Invalid io default' + stop 1 + end if do i=1,12 - if( variables(i)%valid .eqv. .true. ) stop 'Invalid variables default' + if( variables(i)%valid .eqv. .true. ) then + write(*,*) 'Invalid variables default' + stop 1 + end if end do - if( bpWriter%valid .eqv. .true. ) stop 'Invalid engine default' + if( bpWriter%valid .eqv. .true. ) then + write(*,*) 'Invalid engine default' + stop 1 + end if ! Create adios handler passing the communicator and error flag @@ -67,38 +79,62 @@ program TestBPWriteTypes #else call adios2_init(adios, ierr) #endif - if( adios%valid .eqv. .false. ) stop 'Invalid adios2_init' + if( adios%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_init' + stop 1 + end if !!!!!!!!!!!!!!!!!!!!!!!! WRITER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! Declare an IO process configuration inside adios call adios2_declare_io(ioWrite, adios, "ioWrite", ierr) - if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_declare_io' + if( ioWrite%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_declare_io' + stop 1 + end if call adios2_at_io(ioWrite, adios, "ioWrite", ierr) - if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_at_io' + if( ioWrite%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_at_io' + stop 1 + end if call adios2_in_config_file(result, ioWrite, ierr) - if( result .eqv. .true. ) stop 'Invalid ioWrite adios2_in_config_file' + if( result .eqv. .true. ) then + write(*,*) 'Invalid ioWrite adios2_in_config_file' + stop 1 + end if call adios2_set_engine(ioWrite, 'File', ierr) call adios2_set_parameter(ioWrite, 'ProfileUnits', 'Microseconds', ierr) call adios2_get_parameter(param_value, ioWrite, 'ProfileUnits', ierr) - if( param_value /= "Microseconds") stop 'Failed adios2_get_parameter ProfileUnits' + if( param_value /= "Microseconds") then + write(*,*) 'Failed adios2_get_parameter ProfileUnits' + stop 1 + end if call adios2_set_parameters(ioWrite, 'Threads=2, CollectiveMetadata = OFF', ierr) call adios2_get_parameter(param_value, ioWrite, 'Threads', ierr) - if( param_value /= "2") stop 'Failed adios2_get_parameter Threads' + if( param_value /= "2") then + write(*,*) 'Failed adios2_get_parameter Threads' + stop 1 + end if call adios2_get_parameter(param_value, ioWrite, 'CollectiveMetadata', ierr) - if( param_value /= "OFF") stop 'Failed adios2_get_parameter CollectiveMetadata' + if( param_value /= "OFF") then + write(*,*) 'Failed adios2_get_parameter CollectiveMetadata' + stop 1 + end if ! set back the default to make sure writing/reading test works call adios2_clear_parameters(ioWrite, ierr) call adios2_get_parameter(param_value, ioWrite, 'CollectiveMetadata', ierr) - if( param_value /= "") stop 'Still Could retrieve parameter CollectiveMetadata after clearing all parameters' + if( param_value /= "") then + write(*,*) 'Still Could retrieve parameter CollectiveMetadata after clearing all parameters' + stop 1 + end if deallocate(param_value) @@ -169,38 +205,64 @@ program TestBPWriteTypes "x=var_R64 y=var_R64 z=var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) do i=1,13 - if( variables(i)%valid .eqv. .false. ) stop 'Invalid adios2_define_variable' + if( variables(i)%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_define_variable' + stop 1 + end if end do ! Testing adios2_variable_name for just two cases call adios2_variable_name(varName, variables(1), ierr) - if (varName /= 'var_I8') stop 'Invalid adios2_variable_name' + if (varName /= 'var_I8') then + write(*,*) 'Invalid adios2_variable_name' + stop 1 + end if call adios2_variable_name(varName, variables(2), ierr) - if (varName /= 'var_I16') stop 'Invalid adios2_variable_name' + if (varName /= 'var_I16') then + write(*,*) 'Invalid adios2_variable_name' + stop 1 + end if deallocate(varName) ! Open myVector_f.bp in write mode, this launches an engine - if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_io' - if( bpWriter%valid .eqv. .true. ) stop 'Invalid adios2_engine pre-open' + if( ioWrite%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_io' + stop 1 + end if + if( bpWriter%valid .eqv. .true. ) then + write(*,*) 'Invalid adios2_engine pre-open' + stop 1 + end if call adios2_open(bpWriter, ioWrite, "ftypes.bp", adios2_mode_write, ierr) - if( bpWriter%valid .eqv. .false. ) stop 'Invalid adios2_engine post-open' - if( TRIM(bpWriter%name) /= "ftypes.bp") stop 'Invalid adios2_engine name' + if( bpWriter%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_engine post-open' + stop 1 + end if + if( TRIM(bpWriter%name) /= "ftypes.bp") then + write(*,*) 'Invalid adios2_engine name' + stop 1 + end if if( TRIM(bpWriter%type) /= 'BP5Writer') then write(*,*) 'Engine Type ', TRIM(bpWriter%type) - stop 'Invalid adios2_engine type' + write(*,*) 'Invalid adios2_engine type' + stop 1 end if call adios2_io_engine_type(engineType, ioWrite, ierr) if( engineType /= 'File') then ! FIXME, different from the above! write(*,*) 'Engine Type ', engineType - stop 'Invalid type from adios2_engine_type' + write(*,*) 'Invalid type from adios2_engine_type' + stop 1 end if - if( bpWriter%mode /= adios2_mode_write) stop 'Invalid adios2_engine mode' + if( bpWriter%mode /= adios2_mode_write) then + write(*,*) 'Invalid adios2_engine mode' + stop 1 + end if ! Put array contents to bp buffer, based on var1 metadata do i = 1, 3 @@ -232,7 +294,10 @@ program TestBPWriteTypes ! Closes engine1 and deallocates it, becomes unreachable call adios2_close(bpWriter, ierr) - if( bpWriter%valid .eqv. .true. ) stop 'Invalid adios2_close' + if( bpWriter%valid .eqv. .true. ) then + write(*,*) 'Invalid adios2_close' + stop 1 + end if !!!!!!!!!!!!!!!!!!!!!!!! READER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! Declare io reader @@ -241,87 +306,189 @@ program TestBPWriteTypes call adios2_open(bpReader, ioRead, "ftypes.bp", adios2_mode_readRandomAccess, ierr) call adios2_steps(nsteps, bpReader, ierr) - if(nsteps /= 3) stop 'ftypes.bp must have 3 steps' + if(nsteps /= 3) then + write(*,*) 'ftypes.bp must have 3 steps' + stop 1 + end if call adios2_available_variables(ioRead, namestruct, ierr) - if (ierr /= 0) stop 'adios2_available_variables returned with error' - if (.not.namestruct%valid) stop 'adios2_available_variables returned invalid struct' + if (ierr /= 0) then + write(*,*) 'adios2_available_variables returned with error' + stop 1 + end if + if (.not.namestruct%valid) then + write(*,*) 'adios2_available_variables returned invalid struct' + stop 1 + end if write(*,*) 'Number of variables = ', namestruct%count write(*,*) 'Max name length = ', namestruct%max_name_len - if (namestruct%count /= 14) stop 'adios2_available_variables returned not the expected 14' + if (namestruct%count /= 14) then + write(*,*) 'adios2_available_variables returned not the expected 14' + stop 1 + end if allocate(varnamelist(namestruct%count)) call adios2_retrieve_names(namestruct, varnamelist, ierr) - if (ierr /= 0) stop 'adios2_retrieve_names returned with error' + if (ierr /= 0) then + write(*,*) 'adios2_retrieve_names returned with error' + stop 1 + end if do i=1,namestruct%count write(*,'("Var[",i2,"] = ",a12)') i, varnamelist(i) end do deallocate(varnamelist) - if (namestruct%f2c /= 0_8) stop 'namestruct f2c pointer is not null after adios2_retrieve_names()' - if (namestruct%valid) stop 'namestruct is not invalidated after adios2_retrieve_names()' + if (namestruct%f2c /= 0_8) then + write(*,*) 'namestruct f2c pointer is not null after adios2_retrieve_names()' + stop 1 + end if + if (namestruct%valid) then + write(*,*) 'namestruct is not invalidated after adios2_retrieve_names()' + stop 1 + end if call adios2_inquire_variable(variables(1), ioRead, "var_I8", ierr) - if (variables(1)%name /= 'var_I8') stop 'var_I8 not recognized' - if (variables(1)%type /= adios2_type_integer1) stop 'var_I8 type not recognized' + if (variables(1)%name /= 'var_I8') then + write(*,*) 'var_I8 not recognized' + stop 1 + end if + if (variables(1)%type /= adios2_type_integer1) then + write(*,*) 'var_I8 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(1), ierr) - if (ndims /= 1) stop 'var_I8 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I8 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I8 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I8 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(2), ioRead, "var_I16", ierr) - if (variables(2)%name /= 'var_I16') stop 'var_I16 not recognized' - if (variables(2)%type /= adios2_type_integer2) stop 'var_I16 type not recognized' + if (variables(2)%name /= 'var_I16') then + write(*,*) 'var_I16 not recognized' + stop 1 + end if + if (variables(2)%type /= adios2_type_integer2) then + write(*,*) 'var_I16 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(2), ierr) - if (ndims /= 1) stop 'var_I16 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I16 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I16 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I16 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(3), ioRead, "var_I32", ierr) - if (variables(3)%name /= 'var_I32') stop 'var_I32 not recognized' - if (variables(3)%type /= adios2_type_integer4) stop 'var_I32 type not recognized' + if (variables(3)%name /= 'var_I32') then + write(*,*) 'var_I32 not recognized' + stop 1 + end if + if (variables(3)%type /= adios2_type_integer4) then + write(*,*) 'var_I32 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(3), ierr) - if (ndims /= 1) stop 'var_I32 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I32 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I32 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I32 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(4), ioRead, "var_I64", ierr) - if (variables(4)%name /= 'var_I64') stop 'var_I64 not recognized' - if (variables(4)%type /= adios2_type_integer8) stop 'var_I64 type not recognized' + if (variables(4)%name /= 'var_I64') then + write(*,*) 'var_I64 not recognized' + stop 1 + end if + if (variables(4)%type /= adios2_type_integer8) then + write(*,*) 'var_I64 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(4), ierr) - if (ndims /= 1) stop 'var_I64 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I64 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I64 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I64 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(5), ioRead, "var_R32", ierr) - if (variables(5)%name /= 'var_R32') stop 'var_R32 not recognized' - if (variables(5)%type /= adios2_type_real) stop 'var_R32 type not recognized' + if (variables(5)%name /= 'var_R32') then + write(*,*) 'var_R32 not recognized' + stop 1 + end if + if (variables(5)%type /= adios2_type_real) then + write(*,*) 'var_R32 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(5), ierr) - if (ndims /= 1) stop 'var_R32 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_R32 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_R32 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_R32 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(6), ioRead, "var_R64", ierr) - if (variables(6)%name /= 'var_R64') stop 'var_R64 not recognized' - if (variables(6)%type /= adios2_type_dp) stop 'var_R64 type not recognized' + if (variables(6)%name /= 'var_R64') then + write(*,*) 'var_R64 not recognized' + stop 1 + end if + if (variables(6)%type /= adios2_type_dp) then + write(*,*) 'var_R64 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(6), ierr) - if (ndims /= 1) stop 'var_R64 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_R64 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_R64 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_R64 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(13), ioRead, "gvar_Str", ierr) call adios2_get(bpReader, variables(13), inString, ierr) call adios2_perform_gets(bpReader, ierr) - if( inString /= data_Strings(1) ) stop 'gvar_Str read failed' + if( inString /= data_Strings(1) ) then + write(*,*) 'gvar_Str read failed' + stop 1 + end if call adios2_inquire_variable(variables(14), ioRead, "lvar_i32", ierr) allocate(inRanks(isize)) call adios2_get(bpReader, variables(14), inRanks, ierr) call adios2_perform_gets(bpReader, ierr) - if( inRanks(irank+1) /= irank ) stop 'lvar_i32 read failed' + if( inRanks(irank+1) /= irank ) then + write(*,*) 'lvar_i32 read failed' + stop 1 + end if deallocate(inRanks) call adios2_close(bpReader, ierr) ! Deallocates adios and calls its destructor call adios2_finalize(adios, ierr) - if( adios%valid .eqv. .true. ) stop 'Invalid adios2_finalize' + if( adios%valid .eqv. .true. ) then + write(*,*) 'Invalid adios2_finalize' + stop 1 + end if #if ADIOS2_USE_MPI call MPI_Finalize(ierr) From 29b92fa271baca0fcc70effa08b40bc82889c9df Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 17 Mar 2024 10:06:48 -0400 Subject: [PATCH 42/46] See if new test form works with Derived On --- CMakeLists.txt | 2 +- .../bindings/fortran/TestBPWriteTypes.F90 | 289 ++++-------------- 2 files changed, 64 insertions(+), 227 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 8511e152bf..8ee0331e55 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -185,7 +185,7 @@ adios_option(Sodium "Enable support for Sodium for encryption" AUTO) adios_option(Catalyst "Enable support for in situ visualization plugin using ParaView Catalyst" AUTO) adios_option(Campaign "Enable support for Campaigns (requires SQLite3 and ZLIB)" OFF) adios_option(AWSSDK "Enable support for S3 compatible storage using AWS SDK's S3 module" OFF) -adios_option(Derived_Variable "Enable support for derived variables" OFF) +adios_option(Derived_Variable "Enable support for derived variables" ON) adios_option(PIP "Enable support for pip packaging" OFF) option(ADIOS2_Blosc2_PREFER_SHARED "Prefer shared Blosc2 libraries" ON) diff --git a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 index 0be6110352..1db0288765 100644 --- a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 +++ b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 @@ -51,26 +51,14 @@ program TestBPWriteTypes start_dims(1) = irank*inx count_dims(1) = inx - if( adios%valid .eqv. .true. ) then - write(*,*) 'Invalid adios default' - stop 1 - end if - if( ioWrite%valid .eqv. .true. ) then - write(*,*) 'Invalid io default' - stop 1 - end if + if( adios%valid .eqv. .true. ) stop 'Invalid adios default' + if( ioWrite%valid .eqv. .true. ) stop 'Invalid io default' do i=1,12 - if( variables(i)%valid .eqv. .true. ) then - write(*,*) 'Invalid variables default' - stop 1 - end if + if( variables(i)%valid .eqv. .true. ) stop 'Invalid variables default' end do - if( bpWriter%valid .eqv. .true. ) then - write(*,*) 'Invalid engine default' - stop 1 - end if + if( bpWriter%valid .eqv. .true. ) stop 'Invalid engine default' ! Create adios handler passing the communicator and error flag @@ -79,62 +67,38 @@ program TestBPWriteTypes #else call adios2_init(adios, ierr) #endif - if( adios%valid .eqv. .false. ) then - write(*,*) 'Invalid adios2_init' - stop 1 - end if + if( adios%valid .eqv. .false. ) stop 'Invalid adios2_init' !!!!!!!!!!!!!!!!!!!!!!!! WRITER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! Declare an IO process configuration inside adios call adios2_declare_io(ioWrite, adios, "ioWrite", ierr) - if( ioWrite%valid .eqv. .false. ) then - write(*,*) 'Invalid adios2_declare_io' - stop 1 - end if + if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_declare_io' call adios2_at_io(ioWrite, adios, "ioWrite", ierr) - if( ioWrite%valid .eqv. .false. ) then - write(*,*) 'Invalid adios2_at_io' - stop 1 - end if + if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_at_io' call adios2_in_config_file(result, ioWrite, ierr) - if( result .eqv. .true. ) then - write(*,*) 'Invalid ioWrite adios2_in_config_file' - stop 1 - end if + if( result .eqv. .true. ) stop 'Invalid ioWrite adios2_in_config_file' call adios2_set_engine(ioWrite, 'File', ierr) call adios2_set_parameter(ioWrite, 'ProfileUnits', 'Microseconds', ierr) call adios2_get_parameter(param_value, ioWrite, 'ProfileUnits', ierr) - if( param_value /= "Microseconds") then - write(*,*) 'Failed adios2_get_parameter ProfileUnits' - stop 1 - end if + if( param_value /= "Microseconds") stop 'Failed adios2_get_parameter ProfileUnits' call adios2_set_parameters(ioWrite, 'Threads=2, CollectiveMetadata = OFF', ierr) call adios2_get_parameter(param_value, ioWrite, 'Threads', ierr) - if( param_value /= "2") then - write(*,*) 'Failed adios2_get_parameter Threads' - stop 1 - end if + if( param_value /= "2") stop 'Failed adios2_get_parameter Threads' call adios2_get_parameter(param_value, ioWrite, 'CollectiveMetadata', ierr) - if( param_value /= "OFF") then - write(*,*) 'Failed adios2_get_parameter CollectiveMetadata' - stop 1 - end if + if( param_value /= "OFF") stop 'Failed adios2_get_parameter CollectiveMetadata' ! set back the default to make sure writing/reading test works call adios2_clear_parameters(ioWrite, ierr) call adios2_get_parameter(param_value, ioWrite, 'CollectiveMetadata', ierr) - if( param_value /= "") then - write(*,*) 'Still Could retrieve parameter CollectiveMetadata after clearing all parameters' - stop 1 - end if + if( param_value /= "") stop 'Still Could retrieve parameter CollectiveMetadata after clearing all parameters' deallocate(param_value) @@ -200,69 +164,47 @@ program TestBPWriteTypes adios2_null_dims, & adios2_constant_dims, ierr) +#if ADIOS2_USE_Derived_Variable ! derived variable call adios2_define_derived_variable(derived_variable, ioWrite, "derived/magnitude_of_var_R64", & - "x=var_R64 y=var_R64 z=var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) - + "x:var_R64 y:var_R64 z:var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) +#define TOTAL_VAR_COUNT 15 +#else +#define TOTAL_VAR_COUNT 14 +#endif do i=1,13 - if( variables(i)%valid .eqv. .false. ) then - write(*,*) 'Invalid adios2_define_variable' - stop 1 - end if + if( variables(i)%valid .eqv. .false. ) stop 'Invalid adios2_define_variable' end do ! Testing adios2_variable_name for just two cases call adios2_variable_name(varName, variables(1), ierr) - if (varName /= 'var_I8') then - write(*,*) 'Invalid adios2_variable_name' - stop 1 - end if + if (varName /= 'var_I8') stop 'Invalid adios2_variable_name' call adios2_variable_name(varName, variables(2), ierr) - if (varName /= 'var_I16') then - write(*,*) 'Invalid adios2_variable_name' - stop 1 - end if + if (varName /= 'var_I16') stop 'Invalid adios2_variable_name' deallocate(varName) ! Open myVector_f.bp in write mode, this launches an engine - if( ioWrite%valid .eqv. .false. ) then - write(*,*) 'Invalid adios2_io' - stop 1 - end if - if( bpWriter%valid .eqv. .true. ) then - write(*,*) 'Invalid adios2_engine pre-open' - stop 1 - end if + if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_io' + if( bpWriter%valid .eqv. .true. ) stop 'Invalid adios2_engine pre-open' call adios2_open(bpWriter, ioWrite, "ftypes.bp", adios2_mode_write, ierr) - if( bpWriter%valid .eqv. .false. ) then - write(*,*) 'Invalid adios2_engine post-open' - stop 1 - end if - if( TRIM(bpWriter%name) /= "ftypes.bp") then - write(*,*) 'Invalid adios2_engine name' - stop 1 - end if + if( bpWriter%valid .eqv. .false. ) stop 'Invalid adios2_engine post-open' + if( TRIM(bpWriter%name) /= "ftypes.bp") stop 'Invalid adios2_engine name' if( TRIM(bpWriter%type) /= 'BP5Writer') then write(*,*) 'Engine Type ', TRIM(bpWriter%type) - write(*,*) 'Invalid adios2_engine type' - stop 1 + stop 'Invalid adios2_engine type' end if call adios2_io_engine_type(engineType, ioWrite, ierr) if( engineType /= 'File') then ! FIXME, different from the above! write(*,*) 'Engine Type ', engineType - write(*,*) 'Invalid type from adios2_engine_type' - stop 1 + stop 'Invalid type from adios2_engine_type' end if - if( bpWriter%mode /= adios2_mode_write) then - write(*,*) 'Invalid adios2_engine mode' - stop 1 - end if + if( bpWriter%mode /= adios2_mode_write) stop 'Invalid adios2_engine mode' ! Put array contents to bp buffer, based on var1 metadata do i = 1, 3 @@ -294,10 +236,7 @@ program TestBPWriteTypes ! Closes engine1 and deallocates it, becomes unreachable call adios2_close(bpWriter, ierr) - if( bpWriter%valid .eqv. .true. ) then - write(*,*) 'Invalid adios2_close' - stop 1 - end if + if( bpWriter%valid .eqv. .true. ) stop 'Invalid adios2_close' !!!!!!!!!!!!!!!!!!!!!!!! READER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! Declare io reader @@ -306,189 +245,87 @@ program TestBPWriteTypes call adios2_open(bpReader, ioRead, "ftypes.bp", adios2_mode_readRandomAccess, ierr) call adios2_steps(nsteps, bpReader, ierr) - if(nsteps /= 3) then - write(*,*) 'ftypes.bp must have 3 steps' - stop 1 - end if + if(nsteps /= 3) stop 'ftypes.bp must have 3 steps' call adios2_available_variables(ioRead, namestruct, ierr) - if (ierr /= 0) then - write(*,*) 'adios2_available_variables returned with error' - stop 1 - end if - if (.not.namestruct%valid) then - write(*,*) 'adios2_available_variables returned invalid struct' - stop 1 - end if + if (ierr /= 0) stop 'adios2_available_variables returned with error' + if (.not.namestruct%valid) stop 'adios2_available_variables returned invalid struct' write(*,*) 'Number of variables = ', namestruct%count write(*,*) 'Max name length = ', namestruct%max_name_len - if (namestruct%count /= 14) then - write(*,*) 'adios2_available_variables returned not the expected 14' - stop 1 - end if + if (namestruct%count /= TOTAL_VAR_COUNT) stop 'adios2_available_variables returned not the expected 14' allocate(varnamelist(namestruct%count)) call adios2_retrieve_names(namestruct, varnamelist, ierr) - if (ierr /= 0) then - write(*,*) 'adios2_retrieve_names returned with error' - stop 1 - end if + if (ierr /= 0) stop 'adios2_retrieve_names returned with error' do i=1,namestruct%count write(*,'("Var[",i2,"] = ",a12)') i, varnamelist(i) end do deallocate(varnamelist) - if (namestruct%f2c /= 0_8) then - write(*,*) 'namestruct f2c pointer is not null after adios2_retrieve_names()' - stop 1 - end if - if (namestruct%valid) then - write(*,*) 'namestruct is not invalidated after adios2_retrieve_names()' - stop 1 - end if + if (namestruct%f2c /= 0_8) stop 'namestruct f2c pointer is not null after adios2_retrieve_names()' + if (namestruct%valid) stop 'namestruct is not invalidated after adios2_retrieve_names()' call adios2_inquire_variable(variables(1), ioRead, "var_I8", ierr) - if (variables(1)%name /= 'var_I8') then - write(*,*) 'var_I8 not recognized' - stop 1 - end if - if (variables(1)%type /= adios2_type_integer1) then - write(*,*) 'var_I8 type not recognized' - stop 1 - end if + if (variables(1)%name /= 'var_I8') stop 'var_I8 not recognized' + if (variables(1)%type /= adios2_type_integer1) stop 'var_I8 type not recognized' call adios2_variable_shape(shape_in, ndims, variables(1), ierr) - if (ndims /= 1) then - write(*,*) 'var_I8 ndims is not 1' - stop 1 - end if - if (shape_in(1) /= isize*inx) then - write(*,*) 'var_I8 shape_in read failed' - stop 1 - end if + if (ndims /= 1) stop 'var_I8 ndims is not 1' + if (shape_in(1) /= isize*inx) stop 'var_I8 shape_in read failed' call adios2_inquire_variable(variables(2), ioRead, "var_I16", ierr) - if (variables(2)%name /= 'var_I16') then - write(*,*) 'var_I16 not recognized' - stop 1 - end if - if (variables(2)%type /= adios2_type_integer2) then - write(*,*) 'var_I16 type not recognized' - stop 1 - end if + if (variables(2)%name /= 'var_I16') stop 'var_I16 not recognized' + if (variables(2)%type /= adios2_type_integer2) stop 'var_I16 type not recognized' call adios2_variable_shape(shape_in, ndims, variables(2), ierr) - if (ndims /= 1) then - write(*,*) 'var_I16 ndims is not 1' - stop 1 - end if - if (shape_in(1) /= isize*inx) then - write(*,*) 'var_I16 shape_in read failed' - stop 1 - end if + if (ndims /= 1) stop 'var_I16 ndims is not 1' + if (shape_in(1) /= isize*inx) stop 'var_I16 shape_in read failed' call adios2_inquire_variable(variables(3), ioRead, "var_I32", ierr) - if (variables(3)%name /= 'var_I32') then - write(*,*) 'var_I32 not recognized' - stop 1 - end if - if (variables(3)%type /= adios2_type_integer4) then - write(*,*) 'var_I32 type not recognized' - stop 1 - end if + if (variables(3)%name /= 'var_I32') stop 'var_I32 not recognized' + if (variables(3)%type /= adios2_type_integer4) stop 'var_I32 type not recognized' call adios2_variable_shape(shape_in, ndims, variables(3), ierr) - if (ndims /= 1) then - write(*,*) 'var_I32 ndims is not 1' - stop 1 - end if - if (shape_in(1) /= isize*inx) then - write(*,*) 'var_I32 shape_in read failed' - stop 1 - end if + if (ndims /= 1) stop 'var_I32 ndims is not 1' + if (shape_in(1) /= isize*inx) stop 'var_I32 shape_in read failed' call adios2_inquire_variable(variables(4), ioRead, "var_I64", ierr) - if (variables(4)%name /= 'var_I64') then - write(*,*) 'var_I64 not recognized' - stop 1 - end if - if (variables(4)%type /= adios2_type_integer8) then - write(*,*) 'var_I64 type not recognized' - stop 1 - end if + if (variables(4)%name /= 'var_I64') stop 'var_I64 not recognized' + if (variables(4)%type /= adios2_type_integer8) stop 'var_I64 type not recognized' call adios2_variable_shape(shape_in, ndims, variables(4), ierr) - if (ndims /= 1) then - write(*,*) 'var_I64 ndims is not 1' - stop 1 - end if - if (shape_in(1) /= isize*inx) then - write(*,*) 'var_I64 shape_in read failed' - stop 1 - end if + if (ndims /= 1) stop 'var_I64 ndims is not 1' + if (shape_in(1) /= isize*inx) stop 'var_I64 shape_in read failed' call adios2_inquire_variable(variables(5), ioRead, "var_R32", ierr) - if (variables(5)%name /= 'var_R32') then - write(*,*) 'var_R32 not recognized' - stop 1 - end if - if (variables(5)%type /= adios2_type_real) then - write(*,*) 'var_R32 type not recognized' - stop 1 - end if + if (variables(5)%name /= 'var_R32') stop 'var_R32 not recognized' + if (variables(5)%type /= adios2_type_real) stop 'var_R32 type not recognized' call adios2_variable_shape(shape_in, ndims, variables(5), ierr) - if (ndims /= 1) then - write(*,*) 'var_R32 ndims is not 1' - stop 1 - end if - if (shape_in(1) /= isize*inx) then - write(*,*) 'var_R32 shape_in read failed' - stop 1 - end if + if (ndims /= 1) stop 'var_R32 ndims is not 1' + if (shape_in(1) /= isize*inx) stop 'var_R32 shape_in read failed' call adios2_inquire_variable(variables(6), ioRead, "var_R64", ierr) - if (variables(6)%name /= 'var_R64') then - write(*,*) 'var_R64 not recognized' - stop 1 - end if - if (variables(6)%type /= adios2_type_dp) then - write(*,*) 'var_R64 type not recognized' - stop 1 - end if + if (variables(6)%name /= 'var_R64') stop 'var_R64 not recognized' + if (variables(6)%type /= adios2_type_dp) stop 'var_R64 type not recognized' call adios2_variable_shape(shape_in, ndims, variables(6), ierr) - if (ndims /= 1) then - write(*,*) 'var_R64 ndims is not 1' - stop 1 - end if - if (shape_in(1) /= isize*inx) then - write(*,*) 'var_R64 shape_in read failed' - stop 1 - end if + if (ndims /= 1) stop 'var_R64 ndims is not 1' + if (shape_in(1) /= isize*inx) stop 'var_R64 shape_in read failed' call adios2_inquire_variable(variables(13), ioRead, "gvar_Str", ierr) call adios2_get(bpReader, variables(13), inString, ierr) call adios2_perform_gets(bpReader, ierr) - if( inString /= data_Strings(1) ) then - write(*,*) 'gvar_Str read failed' - stop 1 - end if + if( inString /= data_Strings(1) ) stop 'gvar_Str read failed' call adios2_inquire_variable(variables(14), ioRead, "lvar_i32", ierr) allocate(inRanks(isize)) call adios2_get(bpReader, variables(14), inRanks, ierr) call adios2_perform_gets(bpReader, ierr) - if( inRanks(irank+1) /= irank ) then - write(*,*) 'lvar_i32 read failed' - stop 1 - end if + if( inRanks(irank+1) /= irank ) stop 'lvar_i32 read failed' deallocate(inRanks) call adios2_close(bpReader, ierr) ! Deallocates adios and calls its destructor call adios2_finalize(adios, ierr) - if( adios%valid .eqv. .true. ) then - write(*,*) 'Invalid adios2_finalize' - stop 1 - end if + if( adios%valid .eqv. .true. ) stop 'Invalid adios2_finalize' #if ADIOS2_USE_MPI call MPI_Finalize(ierr) From 6d0e2834313826144f9f27ce9c8ff299acbb2535 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 17 Mar 2024 10:15:46 -0400 Subject: [PATCH 43/46] Always use derived_variable, even if not enabled --- testing/adios2/bindings/fortran/TestBPWriteTypes.F90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 index 1db0288765..ca6f33d49e 100644 --- a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 +++ b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 @@ -164,10 +164,10 @@ program TestBPWriteTypes adios2_null_dims, & adios2_constant_dims, ierr) -#if ADIOS2_USE_Derived_Variable ! derived variable call adios2_define_derived_variable(derived_variable, ioWrite, "derived/magnitude_of_var_R64", & "x:var_R64 y:var_R64 z:var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) +#if ADIOS2_USE_Derived_Variable #define TOTAL_VAR_COUNT 15 #else #define TOTAL_VAR_COUNT 14 From 7616097c08d5724786c8a93a774cb3f3f71525c6 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 17 Mar 2024 10:49:23 -0400 Subject: [PATCH 44/46] Whoops, accidently reverted the form of the derivation --- testing/adios2/bindings/fortran/TestBPWriteTypes.F90 | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 index ca6f33d49e..48d31eed7b 100644 --- a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 +++ b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 @@ -166,7 +166,7 @@ program TestBPWriteTypes ! derived variable call adios2_define_derived_variable(derived_variable, ioWrite, "derived/magnitude_of_var_R64", & - "x:var_R64 y:var_R64 z:var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) + "x=var_R64 y=var_R64 z=var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) #if ADIOS2_USE_Derived_Variable #define TOTAL_VAR_COUNT 15 #else From ac372d234ea23690eff625e888a582a30416dfd0 Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 17 Mar 2024 18:44:32 -0400 Subject: [PATCH 45/46] Add definition --- .../adios2/bindings/fortran/CMakeLists.txt | 6 + .../bindings/fortran/TestBPWriteTypes.F90 | 278 ++++++++++++++---- 2 files changed, 227 insertions(+), 57 deletions(-) diff --git a/testing/adios2/bindings/fortran/CMakeLists.txt b/testing/adios2/bindings/fortran/CMakeLists.txt index c026628343..f1664f3d1f 100644 --- a/testing/adios2/bindings/fortran/CMakeLists.txt +++ b/testing/adios2/bindings/fortran/CMakeLists.txt @@ -15,6 +15,9 @@ macro(fortran_add_test_helper testname mpi) add_executable(${tgt} Test${testname}.F90) set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE Fortran) target_link_libraries(${tgt} adios2::fortran) + if (ADIOS2_HAVE_Derived_Variable) + target_compile_definitions(${tgt} PRIVATE -DADIOS2_HAVE_Derived_Variable=1) + endif() add_test( NAME ${pfx}${testname}.Serial COMMAND ${tgt} @@ -26,6 +29,9 @@ macro(fortran_add_test_helper testname mpi) add_executable(${tgt} Test${testname}.F90) set_target_properties(${tgt} PROPERTIES LINKER_LANGUAGE Fortran) target_link_libraries(${tgt} adios2::fortran_mpi MPI::MPI_Fortran) + if (ADIOS2_HAVE_Derived_Variable) + target_compile_definitions(${tgt} PRIVATE -DADIOS2_HAVE_Derived_Variable=1) + endif() add_test( NAME ${pfx}${testname}.MPI COMMAND ${MPIEXEC_COMMAND} $ diff --git a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 index 48d31eed7b..2145baedf8 100644 --- a/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 +++ b/testing/adios2/bindings/fortran/TestBPWriteTypes.F90 @@ -51,14 +51,26 @@ program TestBPWriteTypes start_dims(1) = irank*inx count_dims(1) = inx - if( adios%valid .eqv. .true. ) stop 'Invalid adios default' - if( ioWrite%valid .eqv. .true. ) stop 'Invalid io default' + if( adios%valid .eqv. .true. ) then + write(*,*) 'Invalid adios default' + stop 1 + end if + if( ioWrite%valid .eqv. .true. ) then + write(*,*) 'Invalid io default' + stop 1 + end if do i=1,12 - if( variables(i)%valid .eqv. .true. ) stop 'Invalid variables default' + if( variables(i)%valid .eqv. .true. ) then + write(*,*) 'Invalid variables default' + stop 1 + end if end do - if( bpWriter%valid .eqv. .true. ) stop 'Invalid engine default' + if( bpWriter%valid .eqv. .true. ) then + write(*,*) 'Invalid engine default' + stop 1 + end if ! Create adios handler passing the communicator and error flag @@ -67,38 +79,62 @@ program TestBPWriteTypes #else call adios2_init(adios, ierr) #endif - if( adios%valid .eqv. .false. ) stop 'Invalid adios2_init' + if( adios%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_init' + stop 1 + end if !!!!!!!!!!!!!!!!!!!!!!!! WRITER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! Declare an IO process configuration inside adios call adios2_declare_io(ioWrite, adios, "ioWrite", ierr) - if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_declare_io' + if( ioWrite%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_declare_io' + stop 1 + end if call adios2_at_io(ioWrite, adios, "ioWrite", ierr) - if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_at_io' + if( ioWrite%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_at_io' + stop 1 + end if call adios2_in_config_file(result, ioWrite, ierr) - if( result .eqv. .true. ) stop 'Invalid ioWrite adios2_in_config_file' + if( result .eqv. .true. ) then + write(*,*) 'Invalid ioWrite adios2_in_config_file' + stop 1 + end if call adios2_set_engine(ioWrite, 'File', ierr) call adios2_set_parameter(ioWrite, 'ProfileUnits', 'Microseconds', ierr) call adios2_get_parameter(param_value, ioWrite, 'ProfileUnits', ierr) - if( param_value /= "Microseconds") stop 'Failed adios2_get_parameter ProfileUnits' + if( param_value /= "Microseconds") then + write(*,*) 'Failed adios2_get_parameter ProfileUnits' + stop 1 + end if call adios2_set_parameters(ioWrite, 'Threads=2, CollectiveMetadata = OFF', ierr) call adios2_get_parameter(param_value, ioWrite, 'Threads', ierr) - if( param_value /= "2") stop 'Failed adios2_get_parameter Threads' + if( param_value /= "2") then + write(*,*) 'Failed adios2_get_parameter Threads' + stop 1 + end if call adios2_get_parameter(param_value, ioWrite, 'CollectiveMetadata', ierr) - if( param_value /= "OFF") stop 'Failed adios2_get_parameter CollectiveMetadata' + if( param_value /= "OFF") then + write(*,*) 'Failed adios2_get_parameter CollectiveMetadata' + stop 1 + end if ! set back the default to make sure writing/reading test works call adios2_clear_parameters(ioWrite, ierr) call adios2_get_parameter(param_value, ioWrite, 'CollectiveMetadata', ierr) - if( param_value /= "") stop 'Still Could retrieve parameter CollectiveMetadata after clearing all parameters' + if( param_value /= "") then + write(*,*) 'Still Could retrieve parameter CollectiveMetadata after clearing all parameters' + stop 1 + end if deallocate(param_value) @@ -167,44 +203,70 @@ program TestBPWriteTypes ! derived variable call adios2_define_derived_variable(derived_variable, ioWrite, "derived/magnitude_of_var_R64", & "x=var_R64 y=var_R64 z=var_R64 magnitude(x,y,z)", adios2_derived_var_type_metadata_only, ierr) -#if ADIOS2_USE_Derived_Variable +#if ADIOS2_HAVE_Derived_Variable #define TOTAL_VAR_COUNT 15 #else #define TOTAL_VAR_COUNT 14 #endif do i=1,13 - if( variables(i)%valid .eqv. .false. ) stop 'Invalid adios2_define_variable' + if( variables(i)%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_define_variable' + stop 1 + end if end do ! Testing adios2_variable_name for just two cases call adios2_variable_name(varName, variables(1), ierr) - if (varName /= 'var_I8') stop 'Invalid adios2_variable_name' + if (varName /= 'var_I8') then + write(*,*) 'Invalid adios2_variable_name' + stop 1 + end if call adios2_variable_name(varName, variables(2), ierr) - if (varName /= 'var_I16') stop 'Invalid adios2_variable_name' + if (varName /= 'var_I16') then + write(*,*) 'Invalid adios2_variable_name' + stop 1 + end if deallocate(varName) ! Open myVector_f.bp in write mode, this launches an engine - if( ioWrite%valid .eqv. .false. ) stop 'Invalid adios2_io' - if( bpWriter%valid .eqv. .true. ) stop 'Invalid adios2_engine pre-open' + if( ioWrite%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_io' + stop 1 + end if + if( bpWriter%valid .eqv. .true. ) then + write(*,*) 'Invalid adios2_engine pre-open' + stop 1 + end if call adios2_open(bpWriter, ioWrite, "ftypes.bp", adios2_mode_write, ierr) - if( bpWriter%valid .eqv. .false. ) stop 'Invalid adios2_engine post-open' - if( TRIM(bpWriter%name) /= "ftypes.bp") stop 'Invalid adios2_engine name' + if( bpWriter%valid .eqv. .false. ) then + write(*,*) 'Invalid adios2_engine post-open' + stop 1 + end if + if( TRIM(bpWriter%name) /= "ftypes.bp") then + write(*,*) 'Invalid adios2_engine name' + stop 1 + end if if( TRIM(bpWriter%type) /= 'BP5Writer') then write(*,*) 'Engine Type ', TRIM(bpWriter%type) - stop 'Invalid adios2_engine type' + write(*,*) 'Invalid adios2_engine type' + stop 1 end if call adios2_io_engine_type(engineType, ioWrite, ierr) if( engineType /= 'File') then ! FIXME, different from the above! write(*,*) 'Engine Type ', engineType - stop 'Invalid type from adios2_engine_type' + write(*,*) 'Invalid type from adios2_engine_type' + stop 1 end if - if( bpWriter%mode /= adios2_mode_write) stop 'Invalid adios2_engine mode' + if( bpWriter%mode /= adios2_mode_write) then + write(*,*) 'Invalid adios2_engine mode' + stop 1 + end if ! Put array contents to bp buffer, based on var1 metadata do i = 1, 3 @@ -236,7 +298,10 @@ program TestBPWriteTypes ! Closes engine1 and deallocates it, becomes unreachable call adios2_close(bpWriter, ierr) - if( bpWriter%valid .eqv. .true. ) stop 'Invalid adios2_close' + if( bpWriter%valid .eqv. .true. ) then + write(*,*) 'Invalid adios2_close' + stop 1 + end if !!!!!!!!!!!!!!!!!!!!!!!! READER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! Declare io reader @@ -245,80 +310,179 @@ program TestBPWriteTypes call adios2_open(bpReader, ioRead, "ftypes.bp", adios2_mode_readRandomAccess, ierr) call adios2_steps(nsteps, bpReader, ierr) - if(nsteps /= 3) stop 'ftypes.bp must have 3 steps' + if(nsteps /= 3) then + write(*,*) 'ftypes.bp must have 3 steps' + stop 1 + end if call adios2_available_variables(ioRead, namestruct, ierr) - if (ierr /= 0) stop 'adios2_available_variables returned with error' - if (.not.namestruct%valid) stop 'adios2_available_variables returned invalid struct' + if (ierr /= 0) then + write(*,*) 'adios2_available_variables returned with error' + stop 1 + end if + if (.not.namestruct%valid) then + write(*,*) 'adios2_available_variables returned invalid struct' + stop 1 + end if write(*,*) 'Number of variables = ', namestruct%count write(*,*) 'Max name length = ', namestruct%max_name_len - if (namestruct%count /= TOTAL_VAR_COUNT) stop 'adios2_available_variables returned not the expected 14' + if (namestruct%count /= TOTAL_VAR_COUNT) then + write(*,*) 'adios2_available_variables returned not the expected 14' + stop 1 + end if allocate(varnamelist(namestruct%count)) call adios2_retrieve_names(namestruct, varnamelist, ierr) - if (ierr /= 0) stop 'adios2_retrieve_names returned with error' + if (ierr /= 0) then + write(*,*) 'adios2_retrieve_names returned with error' + stop 1 + end if do i=1,namestruct%count write(*,'("Var[",i2,"] = ",a12)') i, varnamelist(i) end do deallocate(varnamelist) - if (namestruct%f2c /= 0_8) stop 'namestruct f2c pointer is not null after adios2_retrieve_names()' - if (namestruct%valid) stop 'namestruct is not invalidated after adios2_retrieve_names()' + if (namestruct%f2c /= 0_8) then + write(*,*) 'namestruct f2c pointer is not null after adios2_retrieve_names()' + stop 1 + end if + if (namestruct%valid) then + write(*,*) 'namestruct is not invalidated after adios2_retrieve_names()' + stop 1 + end if call adios2_inquire_variable(variables(1), ioRead, "var_I8", ierr) - if (variables(1)%name /= 'var_I8') stop 'var_I8 not recognized' - if (variables(1)%type /= adios2_type_integer1) stop 'var_I8 type not recognized' + if (variables(1)%name /= 'var_I8') then + write(*,*) 'var_I8 not recognized' + stop 1 + end if + if (variables(1)%type /= adios2_type_integer1) then + write(*,*) 'var_I8 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(1), ierr) - if (ndims /= 1) stop 'var_I8 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I8 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I8 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I8 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(2), ioRead, "var_I16", ierr) - if (variables(2)%name /= 'var_I16') stop 'var_I16 not recognized' - if (variables(2)%type /= adios2_type_integer2) stop 'var_I16 type not recognized' + if (variables(2)%name /= 'var_I16') then + write(*,*) 'var_I16 not recognized' + stop 1 + end if + if (variables(2)%type /= adios2_type_integer2) then + write(*,*) 'var_I16 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(2), ierr) - if (ndims /= 1) stop 'var_I16 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I16 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I16 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I16 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(3), ioRead, "var_I32", ierr) - if (variables(3)%name /= 'var_I32') stop 'var_I32 not recognized' - if (variables(3)%type /= adios2_type_integer4) stop 'var_I32 type not recognized' + if (variables(3)%name /= 'var_I32') then + write(*,*) 'var_I32 not recognized' + stop 1 + end if + if (variables(3)%type /= adios2_type_integer4) then + write(*,*) 'var_I32 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(3), ierr) - if (ndims /= 1) stop 'var_I32 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I32 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I32 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I32 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(4), ioRead, "var_I64", ierr) - if (variables(4)%name /= 'var_I64') stop 'var_I64 not recognized' - if (variables(4)%type /= adios2_type_integer8) stop 'var_I64 type not recognized' + if (variables(4)%name /= 'var_I64') then + write(*,*) 'var_I64 not recognized' + stop 1 + end if + if (variables(4)%type /= adios2_type_integer8) then + write(*,*) 'var_I64 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(4), ierr) - if (ndims /= 1) stop 'var_I64 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_I64 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_I64 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_I64 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(5), ioRead, "var_R32", ierr) - if (variables(5)%name /= 'var_R32') stop 'var_R32 not recognized' - if (variables(5)%type /= adios2_type_real) stop 'var_R32 type not recognized' + if (variables(5)%name /= 'var_R32') then + write(*,*) 'var_R32 not recognized' + stop 1 + end if + if (variables(5)%type /= adios2_type_real) then + write(*,*) 'var_R32 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(5), ierr) - if (ndims /= 1) stop 'var_R32 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_R32 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_R32 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_R32 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(6), ioRead, "var_R64", ierr) - if (variables(6)%name /= 'var_R64') stop 'var_R64 not recognized' - if (variables(6)%type /= adios2_type_dp) stop 'var_R64 type not recognized' + if (variables(6)%name /= 'var_R64') then + write(*,*) 'var_R64 not recognized' + stop 1 + end if + if (variables(6)%type /= adios2_type_dp) then + write(*,*) 'var_R64 type not recognized' + stop 1 + end if call adios2_variable_shape(shape_in, ndims, variables(6), ierr) - if (ndims /= 1) stop 'var_R64 ndims is not 1' - if (shape_in(1) /= isize*inx) stop 'var_R64 shape_in read failed' + if (ndims /= 1) then + write(*,*) 'var_R64 ndims is not 1' + stop 1 + end if + if (shape_in(1) /= isize*inx) then + write(*,*) 'var_R64 shape_in read failed' + stop 1 + end if call adios2_inquire_variable(variables(13), ioRead, "gvar_Str", ierr) call adios2_get(bpReader, variables(13), inString, ierr) call adios2_perform_gets(bpReader, ierr) - if( inString /= data_Strings(1) ) stop 'gvar_Str read failed' + if( inString /= data_Strings(1) ) then + write(*,*) 'gvar_Str read failed' + stop 1 + end if call adios2_inquire_variable(variables(14), ioRead, "lvar_i32", ierr) allocate(inRanks(isize)) call adios2_get(bpReader, variables(14), inRanks, ierr) call adios2_perform_gets(bpReader, ierr) - if( inRanks(irank+1) /= irank ) stop 'lvar_i32 read failed' + if( inRanks(irank+1) /= irank ) then + write(*,*) 'lvar_i32 read failed' + stop 1 + end if deallocate(inRanks) call adios2_close(bpReader, ierr) From fcf5c13a4ec87d31ab47bad27912a063b097317b Mon Sep 17 00:00:00 2001 From: Greg Eisenhauer Date: Sun, 17 Mar 2024 20:03:04 -0400 Subject: [PATCH 46/46] Set Derived_Variable to default to OFF --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 8ee0331e55..8511e152bf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -185,7 +185,7 @@ adios_option(Sodium "Enable support for Sodium for encryption" AUTO) adios_option(Catalyst "Enable support for in situ visualization plugin using ParaView Catalyst" AUTO) adios_option(Campaign "Enable support for Campaigns (requires SQLite3 and ZLIB)" OFF) adios_option(AWSSDK "Enable support for S3 compatible storage using AWS SDK's S3 module" OFF) -adios_option(Derived_Variable "Enable support for derived variables" ON) +adios_option(Derived_Variable "Enable support for derived variables" OFF) adios_option(PIP "Enable support for pip packaging" OFF) option(ADIOS2_Blosc2_PREFER_SHARED "Prefer shared Blosc2 libraries" ON)

5;^aF9SoVNef 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 W(#=7$9fx(d`ay$T&kBFT&;J1w`Svvc delta 82627 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 WkzXs_EDdeow`j13i+}G}v*v$W^XsDk diff --git a/testing/adios2/derived/TestBPDerivedCorrectness.cpp b/testing/adios2/derived/TestBPDerivedCorrectness.cpp index f748a777ec..481ef9566d 100644 --- a/testing/adios2/derived/TestBPDerivedCorrectness.cpp +++ b/testing/adios2/derived/TestBPDerivedCorrectness.cpp @@ -42,9 +42,9 @@ TEST(DerivedCorrectness, AddCorrectnessTest) auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off auto addU = bpOut.DefineDerivedVariable(derivedname, - "x:" + varname[0] + " \n" - "y:" + varname[1] + " \n" - "z:" + varname[2] + " \n" + "var x:=" + varname[0] + " \n" + "var y:=" + varname[1] + " \n" + "var z:=" + varname[2] + " \n" "x+y+z", adios2::DerivedVarType::StoreData); // clang-format on @@ -117,9 +117,9 @@ TEST(DerivedCorrectness, MagCorrectnessTest) auto Uz = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off auto magU = bpOut.DefineDerivedVariable(derivedname, - "x:" + varname[0] + " \n" - "y:" + varname[1] + " \n" - "z:" + varname[2] + " \n" + "var x:=" + varname[0] + " \n" + "var y:=" + varname[1] + " \n" + "var z:=" + varname[2] + " \n" "magnitude(x,y,z)", adios2::DerivedVarType::StoreData); // clang-format on @@ -290,9 +290,9 @@ TEST(DerivedCorrectness, CurlCorrectnessTest) auto VZ = bpOut.DefineVariable(varname[2], {Nx, Ny, Nz}, {0, 0, 0}, {Nx, Ny, Nz}); // clang-format off auto curlV = bpOut.DefineDerivedVariable(derivedname, - "Vx:" + varname[0] + " \n" - "Vy:" + varname[1] + " \n" - "Vz:" + varname[2] + " \n" + "var Vx:=" + varname[0] + " \n" + "var Vy:=" + varname[1] + " \n" + "var Vz:=" + varname[2] + " \n" "curl(Vx,Vy,Vz)", adios2::DerivedVarType::StoreData); // clang-format on From 9cec4338694b495d979d84dfb713e983b4807fd3 Mon Sep 17 00:00:00 2001 From: lizdulac Date: Mon, 26 Feb 2024 14:01:10 -0500 Subject: [PATCH 09/46] Clean up --- source/adios2/toolkit/derived/Expression.cpp | 6 +- .../toolkit/derived/parser/ASTDriver.cpp | 9 +- .../adios2/toolkit/derived/parser/ASTDriver.h | 16 ++- .../adios2/toolkit/derived/parser/ASTNode.h | 3 +- source/adios2/toolkit/derived/parser/lexer.l | 34 ++---- .../{driver.cpp => parser-test-driver.cpp} | 0 source/adios2/toolkit/derived/parser/parser.y | 13 +-- .../derived/parser/pregen-source/Makefile | 18 +--- .../derived/parser/pregen-source/lexer.cpp | 97 +++++++----------- .../derived/parser/pregen-source/lexer.h | 2 +- .../derived/parser/pregen-source/parser.cpp | 74 ++++++------- .../derived/parser/pregen-source/simple-c | Bin 469376 -> 373624 bytes 12 files changed, 107 insertions(+), 165 deletions(-) rename source/adios2/toolkit/derived/parser/{driver.cpp => parser-test-driver.cpp} (100%) diff --git a/source/adios2/toolkit/derived/Expression.cpp b/source/adios2/toolkit/derived/Expression.cpp index d25525af50..aebdcfd677 100644 --- a/source/adios2/toolkit/derived/Expression.cpp +++ b/source/adios2/toolkit/derived/Expression.cpp @@ -11,14 +11,16 @@ namespace detail // helper function adios2::detail::ExpressionOperator convert_op(std::string opname) { + adios2::detail::ExpressionOperator op; try { - return adios2::detail::get_op(opname); + op = adios2::detail::get_op(opname); } catch (std::out_of_range& e) { helper::Throw("Derived", "ExprHelper", "get_op", "Parser cannot recognize operator '" + opname + "'."); - } + } + return op; }; adios2::derived::ExpressionTree ASTNode_to_ExpressionTree(adios2::detail::ASTNode *node) diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.cpp b/source/adios2/toolkit/derived/parser/ASTDriver.cpp index 5bde639271..1cfaf757d5 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.cpp +++ b/source/adios2/toolkit/derived/parser/ASTDriver.cpp @@ -13,7 +13,8 @@ ASTDriver::ASTDriver() ASTNode* ASTDriver::getAST () { - std::cout << "Getting AST. Nodes in holding: " << holding.size() << std::endl; + // TODO: check only one ASTNode remains in holding + // else throw error that parsing failed resolve(holding.top()); return holding.top(); } @@ -52,7 +53,6 @@ indx_type ASTDriver::lookup_var_indices(const std::string alias) void ASTDriver::add_lookup_entry(std::string alias, std::string var_name, indx_type indices) { - // aliases.insert(std::tuple>( aliases.insert({alias, {var_name, indices}}); } @@ -63,12 +63,11 @@ void ASTDriver::add_lookup_entry(std::string alias, std::string var_name) void ASTDriver::createNode(std::string op_name, size_t numsubexprs) { - std::cout << "Creating Node " << op_name << " with " << numsubexprs << " subexprs. Current number of ASTNodes in holding: " << holding.size() << std::endl; - - // TODO: convert string op_name to enum (check op existst) ASTNode *node = new ASTNode(op_name, numsubexprs); for (size_t i = 1; i <= numsubexprs; ++i) { + // TODO: check that holding contains ASTNode(s) + // else throw error that parsing failed ASTNode *subexpr = holding.top(); node->insert_subexpr_n(subexpr, numsubexprs - i); holding.pop(); diff --git a/source/adios2/toolkit/derived/parser/ASTDriver.h b/source/adios2/toolkit/derived/parser/ASTDriver.h index 025a30e44f..463ded3394 100644 --- a/source/adios2/toolkit/derived/parser/ASTDriver.h +++ b/source/adios2/toolkit/derived/parser/ASTDriver.h @@ -1,5 +1,5 @@ #ifndef ASTDRIVER_HH_ -# define ASTDRIVER_HH_ +#define ASTDRIVER_HH_ #include #include @@ -8,7 +8,7 @@ #include "parser.h" #include "ASTNode.h" -# define YY_DECL \ +#define YY_DECL \ adios2::detail::parser::symbol_type yylex (adios2::detail::ASTDriver& drv) YY_DECL; @@ -43,23 +43,21 @@ class ASTDriver void createNode(std::string, indx_type); // Whether to generate parser debug traces. - bool trace_parsing; + bool trace_parsing = false; // Whether to generate scanner debug traces. - bool trace_scanning; + bool trace_scanning = false; // The token's location used by the scanner. adios2::detail::location location; private: ASTNode* root; - // count of how many ASTNodes exist - size_t num_nodes; - // While parsing, holds ASTNodes until parent node is created // (since root node is created last from bottom up design) std::stack holding; - - // map alias names to variable names and indices from alias definition + + // Variable lookup table: maps alias names + // to variable names and indices from alias definition std::map> aliases; }; diff --git a/source/adios2/toolkit/derived/parser/ASTNode.h b/source/adios2/toolkit/derived/parser/ASTNode.h index c5ac856657..64feb45ad2 100644 --- a/source/adios2/toolkit/derived/parser/ASTNode.h +++ b/source/adios2/toolkit/derived/parser/ASTNode.h @@ -1,5 +1,5 @@ #ifndef ASTNODE_HH -# define ASTNODE_HH +#define ASTNODE_HH #include #include #include @@ -29,6 +29,7 @@ class ASTNode std::string get_varname(); std::vector> get_indices(); double get_value(); + void set_varname(const std::string); void set_indices(const std::vector>); diff --git a/source/adios2/toolkit/derived/parser/lexer.l b/source/adios2/toolkit/derived/parser/lexer.l index a6b16180bf..04a23e7d5f 100644 --- a/source/adios2/toolkit/derived/parser/lexer.l +++ b/source/adios2/toolkit/derived/parser/lexer.l @@ -1,30 +1,11 @@ -/* Scanner for calc++. -*- C++ -*- - - Copyright (C) 2005-2015, 2018-2021 Free Software Foundation, Inc. - - This file is part of Bison, the GNU Compiler Compiler. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ - -%{ /* -*- C++ -*- */ -# include -# include -# include -# include // strerror -# include +%{ +#include +#include +#include +#include // strerror +#include #include "ASTDriver.h" -# include "parser.h" +#include "parser.h" %} %{ @@ -164,6 +145,5 @@ adios2::detail::ASTDriver::parse (const std::string input) yy_scan_string(input.c_str()); parse.set_debug_level (trace_parsing); parse (); - std::cout << "Parsed input: " << input << std::endl; return getAST(); } diff --git a/source/adios2/toolkit/derived/parser/driver.cpp b/source/adios2/toolkit/derived/parser/parser-test-driver.cpp similarity index 100% rename from source/adios2/toolkit/derived/parser/driver.cpp rename to source/adios2/toolkit/derived/parser/parser-test-driver.cpp diff --git a/source/adios2/toolkit/derived/parser/parser.y b/source/adios2/toolkit/derived/parser/parser.y index 8f184aabfe..32d0192a1a 100644 --- a/source/adios2/toolkit/derived/parser/parser.y +++ b/source/adios2/toolkit/derived/parser/parser.y @@ -1,4 +1,4 @@ -%skeleton "lalr1.cc" // -*- C++ -*- +%skeleton "lalr1.cc" %require "3.8.2" %header @@ -48,16 +48,7 @@ VAR "var" ; -/* -%token NUM -%token ALIAS -%token PATH -%token FUNCTION -*/ %token OPERATOR -/* -%token > INDICES -*/ %token IDENTIFIER "identifier" %token VARNAME %token INT "number" @@ -68,7 +59,7 @@ %% %start unit; -unit: assignments exp { /*drv.root = $2;*//*drv.result = $2;*/ }; +unit: assignments exp { }; assignments: %empty {} diff --git a/source/adios2/toolkit/derived/parser/pregen-source/Makefile b/source/adios2/toolkit/derived/parser/pregen-source/Makefile index 3b1342ce16..411381b732 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/Makefile +++ b/source/adios2/toolkit/derived/parser/pregen-source/Makefile @@ -1,27 +1,17 @@ -USE_BISON_3.8 = true CC = g++ PARSER_SOURCE = ../ OPT = -std=c++11 -I$(PARSER_SOURCE) -I./ -ifdef USE_BISON_3.8 -BISON = /usr/local/Cellar/bison/3.8.2/bin/bison -PARSER = parser.y -else -BISON = /usr/bin/bison -PARSER = parser.y -endif +BISON = bison -simple-c: $(PARSER_SOURCE)/driver.cpp $(PARSER_SOURCE)/ASTDriver.cpp $(PARSER_SOURCE)/ASTNode.cpp lexer.cpp parser.cpp +simple-c: $(PARSER_SOURCE)/parser-test-driver.cpp $(PARSER_SOURCE)/ASTDriver.cpp $(PARSER_SOURCE)/ASTNode.cpp lexer.cpp parser.cpp $(CC) $(OPT) $^ -o $@ lexer.h lexer.cpp: $(PARSER_SOURCE)/lexer.l flex --header-file=lexer.h -o lexer.cpp $(PARSER_SOURCE)/lexer.l -parser.h parser.cpp: $(PARSER_SOURCE)/$(PARSER) +parser.h parser.cpp: $(PARSER_SOURCE)/parser.y $(BISON) --version - $(BISON) -d -v --defines=parser.h -o parser.cpp $(PARSER_SOURCE)/$(PARSER) -ifndef USE_BISON_3.8 - echo "\n#include \"ASTNode.h\"\n\nASTNode* parse_expression(const char* input);" >> parser.h -endif + $(BISON) -d -v --defines=parser.h -o parser.cpp $(PARSER_SOURCE)/parser.y clean: rm *.o *~ lexer.cpp lexer.h parser.cpp parser.h parser.hpp parser.output location.hh simple-c diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp index d0601fa284..df1255e287 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.cpp @@ -531,8 +531,8 @@ int yy_flex_debug = 1; static const flex_int16_t yy_rule_linenum[16] = { 0, - 128, 129, 131, 132, 133, 134, 135, 136, 137, 139, - 140, 141, 142, 143, 144 + 109, 110, 112, 113, 114, 115, 116, 117, 118, 120, + 121, 122, 123, 124, 125 } ; /* The intent behind this definition is that it'll catch @@ -544,34 +544,16 @@ static const flex_int16_t yy_rule_linenum[16] = #define YY_RESTORE_YY_MORE_OFFSET char *yytext; #line 1 "..//lexer.l" -/* Scanner for calc++. -*- C++ -*- - - Copyright (C) 2005-2015, 2018-2021 Free Software Foundation, Inc. - - This file is part of Bison, the GNU Compiler Compiler. - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . */ -#line 21 "..//lexer.l" -# include -# include -# include -# include // strerror -# include +#line 2 "..//lexer.l" +#include +#include +#include +#include // strerror +#include #include "ASTDriver.h" -# include "parser.h" -#line 573 "lexer.cpp" -#line 31 "..//lexer.l" +#include "parser.h" +#line 555 "lexer.cpp" +#line 12 "..//lexer.l" #if defined __clang__ # define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) #endif @@ -640,18 +622,18 @@ char *yytext; #if defined GCC_VERSION && 900 <= GCC_VERSION # pragma GCC diagnostic ignored "-Wuseless-cast" #endif -#line 643 "lexer.cpp" +#line 625 "lexer.cpp" #define YY_NO_INPUT 1 -#line 104 "..//lexer.l" +#line 85 "..//lexer.l" // A number symbol corresponding to the value in S. adios2::detail::parser::symbol_type make_INT (const std::string &s, const adios2::detail::parser::location_type& loc); -#line 649 "lexer.cpp" -#line 117 "..//lexer.l" +#line 631 "lexer.cpp" +#line 98 "..//lexer.l" // Code run each time a pattern is matched. # define YY_USER_ACTION loc.columns (yyleng); -#line 653 "lexer.cpp" -#line 654 "lexer.cpp" +#line 635 "lexer.cpp" +#line 636 "lexer.cpp" #define INITIAL 0 @@ -929,16 +911,16 @@ YY_DECL { /* %% [7.0] user's declarations go here */ -#line 120 "..//lexer.l" +#line 101 "..//lexer.l" -#line 123 "..//lexer.l" +#line 104 "..//lexer.l" // A handy shortcut to the location held by the adios2::detail::ASTDriver. adios2::detail::location& loc = drv.location; // Code run each time yylex is called. loc.step (); -#line 941 "lexer.cpp" +#line 923 "lexer.cpp" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -1016,93 +998,93 @@ YY_DECL case 1: YY_RULE_SETUP -#line 128 "..//lexer.l" +#line 109 "..//lexer.l" loc.step (); YY_BREAK case 2: /* rule 2 can match eol */ YY_RULE_SETUP -#line 129 "..//lexer.l" +#line 110 "..//lexer.l" loc.lines (yyleng); loc.step (); return adios2::detail::parser::make_ENDL (loc); YY_BREAK case 3: YY_RULE_SETUP -#line 131 "..//lexer.l" +#line 112 "..//lexer.l" return adios2::detail::parser::make_ASSIGN (loc); YY_BREAK case 4: YY_RULE_SETUP -#line 132 "..//lexer.l" +#line 113 "..//lexer.l" return adios2::detail::parser::make_COMMA (loc); YY_BREAK case 5: YY_RULE_SETUP -#line 133 "..//lexer.l" +#line 114 "..//lexer.l" return adios2::detail::parser::make_COLON (loc); YY_BREAK case 6: YY_RULE_SETUP -#line 134 "..//lexer.l" +#line 115 "..//lexer.l" return adios2::detail::parser::make_L_PAREN (loc); YY_BREAK case 7: YY_RULE_SETUP -#line 135 "..//lexer.l" +#line 116 "..//lexer.l" return adios2::detail::parser::make_R_PAREN (loc); YY_BREAK case 8: YY_RULE_SETUP -#line 136 "..//lexer.l" +#line 117 "..//lexer.l" return adios2::detail::parser::make_L_BRACE (loc); YY_BREAK case 9: YY_RULE_SETUP -#line 137 "..//lexer.l" +#line 118 "..//lexer.l" return adios2::detail::parser::make_R_BRACE (loc); YY_BREAK case 10: YY_RULE_SETUP -#line 139 "..//lexer.l" +#line 120 "..//lexer.l" return make_INT (yytext, loc); YY_BREAK case 11: YY_RULE_SETUP -#line 140 "..//lexer.l" +#line 121 "..//lexer.l" return adios2::detail::parser::make_VAR (loc); YY_BREAK case 12: YY_RULE_SETUP -#line 141 "..//lexer.l" +#line 122 "..//lexer.l" return adios2::detail::parser::make_OPERATOR (yytext, loc); YY_BREAK case 13: YY_RULE_SETUP -#line 142 "..//lexer.l" +#line 123 "..//lexer.l" return adios2::detail::parser::make_IDENTIFIER (yytext, loc); YY_BREAK case 14: YY_RULE_SETUP -#line 143 "..//lexer.l" +#line 124 "..//lexer.l" return adios2::detail::parser::make_VARNAME (yytext, loc); YY_BREAK case 15: YY_RULE_SETUP -#line 144 "..//lexer.l" +#line 125 "..//lexer.l" { throw adios2::detail::parser::syntax_error (loc, "invalid character: " + std::string(yytext)); } YY_BREAK case YY_STATE_EOF(INITIAL): -#line 148 "..//lexer.l" +#line 129 "..//lexer.l" return adios2::detail::parser::make_YYEOF (loc); YY_BREAK case 16: YY_RULE_SETUP -#line 149 "..//lexer.l" +#line 130 "..//lexer.l" ECHO; YY_BREAK -#line 1105 "lexer.cpp" +#line 1087 "lexer.cpp" case YY_END_OF_BUFFER: { @@ -2207,7 +2189,7 @@ void yyfree (void * ptr ) /* %ok-for-header */ -#line 149 "..//lexer.l" +#line 130 "..//lexer.l" adios2::detail::parser::symbol_type @@ -2227,7 +2209,6 @@ adios2::detail::ASTDriver::parse (const std::string input) yy_scan_string(input.c_str()); parse.set_debug_level (trace_parsing); parse (); - std::cout << "Parsed input: " << input << std::endl; return getAST(); } diff --git a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h index 23fe8df056..f6edccecf8 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/lexer.h +++ b/source/adios2/toolkit/derived/parser/pregen-source/lexer.h @@ -581,7 +581,7 @@ extern int yylex (void); #undef yyTABLES_NAME #endif -#line 149 "..//lexer.l" +#line 130 "..//lexer.l" #line 587 "lexer.h" diff --git a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp index 0f610ee6a0..5286dcd0cd 100644 --- a/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp +++ b/source/adios2/toolkit/derived/parser/pregen-source/parser.cpp @@ -643,187 +643,187 @@ namespace adios2 { namespace detail { switch (yyn) { case 2: // unit: assignments exp -#line 71 "..//parser.y" - { /*drv.root = $2;*//*drv.result = $2;*/ } +#line 62 "..//parser.y" + { } #line 649 "parser.cpp" break; case 3: // assignments: %empty -#line 74 "..//parser.y" +#line 65 "..//parser.y" {} #line 655 "parser.cpp" break; case 4: // assignments: "var" assignment "\n" assignments -#line 75 "..//parser.y" +#line 66 "..//parser.y" {} #line 661 "parser.cpp" break; case 5: // assignment: "identifier" ":=" VARNAME -#line 78 "..//parser.y" +#line 69 "..//parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 667 "parser.cpp" break; case 6: // assignment: "identifier" ":=" "identifier" -#line 79 "..//parser.y" +#line 70 "..//parser.y" { drv.add_lookup_entry(yystack_[2].value.as < std::string > (), yystack_[0].value.as < std::string > ()); } #line 673 "parser.cpp" break; case 7: // assignment: "identifier" ":=" VARNAME "[" indices_list "]" -#line 80 "..//parser.y" +#line 71 "..//parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 679 "parser.cpp" break; case 8: // assignment: "identifier" ":=" "identifier" "[" indices_list "]" -#line 81 "..//parser.y" +#line 72 "..//parser.y" { drv.add_lookup_entry(yystack_[5].value.as < std::string > (), yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 685 "parser.cpp" break; case 9: // indices_list: indices_list "," index -#line 84 "..//parser.y" +#line 75 "..//parser.y" { yystack_[2].value.as < std::vector> > ().push_back(yystack_[0].value.as < std::tuple > ()); yylhs.value.as < std::vector> > () = yystack_[2].value.as < std::vector> > (); } #line 691 "parser.cpp" break; case 10: // indices_list: index -#line 85 "..//parser.y" +#line 76 "..//parser.y" { yylhs.value.as < std::vector> > () = {yystack_[0].value.as < std::tuple > ()}; } #line 697 "parser.cpp" break; case 11: // indices_list: %empty -#line 86 "..//parser.y" +#line 77 "..//parser.y" { yylhs.value.as < std::vector> > () = {}; } #line 703 "parser.cpp" break; case 12: // index: "number" ":" "number" ":" "number" -#line 89 "..//parser.y" +#line 80 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[4].value.as < int > (), yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 709 "parser.cpp" break; case 13: // index: ":" "number" ":" "number" -#line 90 "..//parser.y" +#line 81 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[2].value.as < int > (), yystack_[0].value.as < int > ()}; } #line 715 "parser.cpp" break; case 14: // index: "number" ":" ":" "number" -#line 91 "..//parser.y" +#line 82 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), -1, yystack_[0].value.as < int > ()}; } #line 721 "parser.cpp" break; case 15: // index: "number" ":" "number" ":" -#line 92 "..//parser.y" +#line 83 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[3].value.as < int > (), yystack_[1].value.as < int > (), 1}; } #line 727 "parser.cpp" break; case 16: // index: "number" ":" "number" -#line 93 "..//parser.y" +#line 84 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 733 "parser.cpp" break; case 17: // index: ":" ":" "number" -#line 94 "..//parser.y" +#line 85 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, yystack_[0].value.as < int > ()}; } #line 739 "parser.cpp" break; case 18: // index: ":" "number" ":" -#line 95 "..//parser.y" +#line 86 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[1].value.as < int > (), 1}; } #line 745 "parser.cpp" break; case 19: // index: ":" "number" -#line 96 "..//parser.y" +#line 87 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, yystack_[0].value.as < int > (), 1}; } #line 751 "parser.cpp" break; case 20: // index: "number" ":" ":" -#line 97 "..//parser.y" +#line 88 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[2].value.as < int > (), -1, 1}; } #line 757 "parser.cpp" break; case 21: // index: "number" ":" -#line 98 "..//parser.y" +#line 89 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[1].value.as < int > (), -1, 1}; } #line 763 "parser.cpp" break; case 22: // index: "number" -#line 99 "..//parser.y" +#line 90 "..//parser.y" { yylhs.value.as < std::tuple > () = {yystack_[0].value.as < int > (), yystack_[0].value.as < int > (), 1}; } #line 769 "parser.cpp" break; case 23: // index: %empty -#line 100 "..//parser.y" +#line 91 "..//parser.y" { yylhs.value.as < std::tuple > () = {-1, -1, 1}; } #line 775 "parser.cpp" break; case 24: // exp: "number" -#line 104 "..//parser.y" +#line 95 "..//parser.y" { yylhs.value.as < int > () = yystack_[0].value.as < int > (); } #line 781 "parser.cpp" break; case 25: // exp: exp OPERATOR exp -#line 105 "..//parser.y" +#line 96 "..//parser.y" { drv.createNode(yystack_[1].value.as < std::string > (), 2); } #line 787 "parser.cpp" break; case 26: // exp: "identifier" "(" list ")" -#line 106 "..//parser.y" +#line 97 "..//parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < int > ()); } #line 793 "parser.cpp" break; case 27: // exp: "identifier" "[" indices_list "]" -#line 107 "..//parser.y" +#line 98 "..//parser.y" { drv.createNode(yystack_[3].value.as < std::string > (), yystack_[1].value.as < std::vector> > ()); } #line 799 "parser.cpp" break; case 28: // exp: "identifier" -#line 108 "..//parser.y" +#line 99 "..//parser.y" { drv.createNode(yystack_[0].value.as < std::string > ()); } #line 805 "parser.cpp" break; case 29: // exp: "(" exp ")" -#line 109 "..//parser.y" +#line 100 "..//parser.y" { } #line 811 "parser.cpp" break; case 30: // list: exp "," list -#line 113 "..//parser.y" +#line 104 "..//parser.y" { yylhs.value.as < int > () = yystack_[0].value.as < int > () + 1; } #line 817 "parser.cpp" break; case 31: // list: exp -#line 114 "..//parser.y" +#line 105 "..//parser.y" { yylhs.value.as < int > () = 1; } #line 823 "parser.cpp" break; case 32: // list: %empty -#line 115 "..//parser.y" +#line 106 "..//parser.y" { yylhs.value.as < int > () = 0; } #line 829 "parser.cpp" break; @@ -1379,10 +1379,10 @@ namespace adios2 { namespace detail { const signed char parser::yyrline_[] = { - 0, 71, 71, 74, 75, 78, 79, 80, 81, 84, - 85, 86, 89, 90, 91, 92, 93, 94, 95, 96, - 97, 98, 99, 100, 104, 105, 106, 107, 108, 109, - 113, 114, 115 + 0, 62, 62, 65, 66, 69, 70, 71, 72, 75, + 76, 77, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 95, 96, 97, 98, 99, 100, + 104, 105, 106 }; void @@ -1417,7 +1417,7 @@ namespace adios2 { namespace detail { } } // adios2::detail #line 1419 "parser.cpp" -#line 116 "..//parser.y" +#line 107 "..//parser.y" void diff --git a/source/adios2/toolkit/derived/parser/pregen-source/simple-c b/source/adios2/toolkit/derived/parser/pregen-source/simple-c index 60cbdc32f99ad4011a85c76ece9b40190fa356a2..7f184fd9ca332b487293c581753f2b42006e8689 100755 GIT binary patch delta 73725 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 literal 469376 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