<?xml version="1.0" encoding="utf-8"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="/xl/worksheets/sheet1.xml" Id="R4f1c94c378d64409" />
    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="/xl/styles.xml" Id="R48c49c2535d74bcc" />
    <Relationship Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings" Target="/xl/sharedStrings.xml" Id="R5c29e56ada2e432c" />
</Relationships>

//join basepath and filename (caller must free result)
XML_Char* join_basepath_filename (const XML_Char* basepath, const XML_Char* filename)
{
  XML_Char* result = NULL;
  if (filename && *filename) {
    size_t basepathlen = (basepath ? XML_Char_len(basepath) : 0);
    size_t filenamelen = XML_Char_len(filename);
    if ((result = XML_Char_malloc(basepathlen + filenamelen + 1)) != NULL) {

        if(filename[0] == '/') {
            // the filename is written as an 'absolute' path, we need to
            // remove the leading slash, but otherwise return as-is
            XML_Char_poscpy(result, 0, filename + 1, filenamelen - 1);
            result[filenamelen - 1] = 0;
            return result;
        }
        
        if (basepathlen > 0)
        XML_Char_poscpy(result, 0, basepath, basepathlen);
      XML_Char_poscpy(result, basepathlen, filename, filenamelen);
      result[basepathlen + filenamelen] = 0;
    }
  }
  return result;
}

<worksheet>
 <dimension ref="A1:B20"/>
 <sheetViews>
  <sheetView ...

#include <xlsxio_read.h>
#include <xlsxio_write.h>
#include <stdio.h>
#include <string>
#include <Windows.h>
using namespace std;

int read_xlsx() {
  //open .xlsx file for reading
xlsxioreader xlsxioread;
if ((xlsxioread = xlsxioread_open("d:\\0801_test.xlsx")) == NULL) {
  fprintf(stderr, "Error opening .xlsx file\n");
  return 1;
}

//read values from first sheet
char* value;
xlsxioreadersheet sheet;
const char* sheetname = NULL;
printf("Contents of first sheet:\n");
if ((sheet = xlsxioread_sheet_open(xlsxioread, sheetname, XLSXIOREAD_SKIP_EMPTY_ROWS)) != NULL) {
  //read all rows
  while (xlsxioread_sheet_next_row(sheet)) {
    //read all columns
    while ((value = xlsxioread_sheet_next_cell(sheet)) != NULL) {
      printf("%s\t", value);
      //free(value);
    }
    printf("\n");
  }
  xlsxioread_sheet_close(sheet);
}

//clean up
xlsxioread_close(xlsxioread);

return 0;
}

int write_xlsx() {
//open .xlsx file for writing (will overwrite if it already exists)
xlsxiowriter handle;
if ((handle = xlsxiowrite_open("d:\\test_xlsx.xlsx", "MySheet")) == NULL) {
  fprintf(stderr, "Error creating .xlsx file\n");
  return 1;
}

//write column names
xlsxiowrite_add_column(handle, "Col1", 16);
xlsxiowrite_add_column(handle, "Col2", 0);
xlsxiowrite_next_row(handle);

//write data
int i;
for (i = 0; i < 1000; i++) {
  xlsxiowrite_add_cell_string(handle, "test");
  xlsxiowrite_add_cell_int(handle, i);
  xlsxiowrite_next_row(handle);
}

//close .xlsx file
xlsxiowrite_close(handle);

return 0;
}

int main() {
  read_xlsx();
  write_xlsx();

return 0;
}

* thread #10, stop reason = EXC_BAD_ACCESS (code=1, address=0x0)
    frame #0: 0x00007fff65e1a232 libsystem_c.dylib`strlen + 18
    frame #1: 0x000000010aadf086 xlsx.node`unzLocateFile(file=0x0000000104c13140, szFileName=0x0000000000000000, iCaseSensitivity=0) at unzip.c:1253
    frame #2: 0x000000010aaa6fef xlsx.node`XML_Char_openzip(archive=0x0000000104c13140, filename=0x0000000000000000, flags=0) at xlsxio_read.c:43
    frame #3: 0x000000010aaa6e52 xlsx.node`expat_process_zip_file(zip=0x0000000104c13140, filename=0x0000000000000000, start_handler=(xlsx.node`shared_strings_callback_find_sharedstringtable_start at xlsxio_read_sharedstrings.c:125), end_handler=0x0000000000000000, data_handler=0x0000000000000000, callbackdata=0x0000700007a30ec0, xmlparser=0x0000700007a30ec0) at xlsxio_read.c:139
    frame #4: 0x000000010aaa9ade xlsx.node`xlsxioread_process(handle=0x0000000104c058b0, sheetname=0x0000000000000000, flags=129, cell_callback=0x0000000000000000, row_callback=0x0000000000000000, callbackdata=0x0000000104c1cb50) at xlsxio_read.c:1223
  * frame #5: 0x000000010aaaa05f xlsx.node`xlsxioread_sheet_open(handle=0x0000000104c058b0, sheetname=0x0000000000000000, flags=1) at xlsxio_read.c:1350
    frame #6: 0x000000010aa75ff8 xlsx.node`xlsx::extractAllRows(sheetname=0x0000000000000000, xreader=0x0000700007a349e8, hasHeaders=false, headerTransformMap=size=0, deletes=size=0, doPascalCase=false, pascalWords=size=0) at XlsxReaderFunctions.h:73
    frame #7: 0x000000010aa73674 xlsx.node`xlsx::extractAllData(filename="/Users/mjb/Documents/repos/xlsx-util/tests/sci-bug.xlsx", hasHeaders=false, headerTransformMap=size=0, deletes=size=0, doPascalCase=false, pascalWords=size=0) at XlsxReaderFunctions.h:52
    frame #8: 0x000000010aa72b7c xlsx.node`xlsx::AsyncReader::Execute(this=0x00000001061139f0) at AsyncReader.cpp:34
    frame #9: 0x000000010aa700c9 xlsx.node`Napi::AsyncWorker::OnExecute(env=0x0000000104d2bbb0, this_pointer=0x00000001061139f0) at napi-inl.h:3170
    frame #10: 0x00000001000937ff node`(anonymous namespace)::uvimpl::Work::ExecuteCallback(req=0x000000010610dd60) at node_api.cc:3363
    frame #11: 0x000000010171c201 node`uv__queue_work(w=0x000000010610ddb8) at threadpool.c:259
    frame #12: 0x000000010171c8e6 node`worker(arg=0x0000000000000000) at threadpool.c:83
    frame #13: 0x0000000104b65665 libsystem_pthread.dylib`_pthread_body + 340
    frame #14: 0x0000000104b65511 libsystem_pthread.dylib`_pthread_start + 377
    frame #15: 0x0000000104b64bfd libsystem_pthread.dylib`thread_start + 13

#include <xlsxio_read.h>

int main() {

	//open .xlsx file for reading
	xlsxioreader xlsxioread;
	if ((xlsxioread = xlsxioread_open("Transmission_Log.xlsx")) == NULL) {
		fprintf(stderr, "Error opening .xlsx file\n");
		return 1;
	}

	//read values from first sheet
	char* value;
	xlsxioreadersheet sheet;
	const char* sheetname = NULL;
	printf("Contents of first sheet:\n");
	if ((sheet = xlsxioread_sheet_open(xlsxioread, sheetname, XLSXIOREAD_SKIP_EMPTY_ROWS)) != NULL) {
		//read all rows
		while (xlsxioread_sheet_next_row(sheet)) {
			//read all columns
			while ((value = xlsxioread_sheet_next_cell(sheet)) != NULL) {
				printf("%s\t", value);
				free(value);
			}
			printf("\n");
		}
		xlsxioread_sheet_close(sheet);
	}

	//clean up
	xlsxioread_close(xlsxioread);

}

# add a target to generate API documentation with Doxygen
OPTION(BUILD_DOCUMENTATION "Create and install API documentation (requires Doxygen)" ${DOXYGEN_FOUND})

IF(BUILD_DOCUMENTATION)
  IF(NOT DOXYGEN_FOUND)
    MESSAGE(FATAL_ERROR "Doxygen is needed to build the documentation.")
  ENDIF()

  ADD_CUSTOM_TARGET(doc ALL
    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/doc/Doxyfile
    #WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
    WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    COMMENT "Generating API documentation with Doxygen"
    VERBATIM
  )
  INSTALL(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/doc/man
    DESTINATION .
  )
ENDIF()

<?xml version="1.0" encoding="utf-8"?>
<x:sst xmlns:x="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
    <x:si>
<x:t>NPANXX</x:t></x:si><x:si>
<x:t>JUR</x:t></x:si><x:si>
<x:t>CARRIERGRP</x:t></x:si><x:si>
<x:t>DETAILED_CARRIERGRP</x:t></x:si><x:si>
<x:t>ST</x:t></x:si><x:si>
<x:t>LATA</x:t></x:si><x:si>
...

int len = "sst'.length();
if( element.name.last(len) == "sst")

xlsxiowriter xlsxiowrite = xlsxiowrite_open("test.xlsx","Sheet1");
char value[3];
for(int i=0; i<30; i++) {
	sprintf(value, "%d", i);
	//printf("%s\n",str);
	xlsxiowrite_add_column(xlsxiowrite, value, 0);
	//xlsxiowrite_add_cell_string(xlsxiowrite,value);
}
xlsxiowrite_close(xlsxiowrite);

#ifdef _WIN32
    #include <io.h>
#else
    #include <unistd.h>
#endif

#ifdef _WIN32
    #define PRIi64 "I64i"
#else
    #include <inttypes.h>
#endif

    bool
    Val::isScientificOrDecimal( const std::string& inVal, double& outVal )
    {
        outVal = 0.0;
        SciPart part = SciPart::start;
        std::stringstream base;
        std::stringstream exp;

        for( const auto c : inVal )
        {
            if( part == SciPart::start )
            {
                if( c == '-' )
                {
                    base << c;
                    part = SciPart::baseSign;
                }
                else if( std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    part = SciPart::baseInt;
                    base << c;
                }
                else
                {
                    return false;
                }
            }
            else if( part == SciPart::baseSign )
            {
                if( !std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    return false;
                }
                else
                {
                    part = SciPart::baseInt;
                    base << c;
                }
            }
            else if( part == SciPart::baseInt )
            {
                if( c == 'e' || c == 'E' )
                {
                    part = SciPart::e;
                }
                else if( c == '.' )
                {
                    base << c;
                    part = SciPart::basePoint;
                }
                else if( std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    base << c;
                }
                else
                {
                    return false;
                }
            }
            else if( part == SciPart::basePoint )
            {
                if( !std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    return false;
                }
                else
                {
                    part = SciPart::baseDec;
                    base << c;
                }
            }
            else if( part == SciPart::baseDec )
            {
                if( c == 'E' || c == 'e' )
                {
                    part = SciPart::e;
                }
                else if( std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    base << c;
                }
                else
                {
                    return false;
                }
            }
            else if( part == SciPart::e )
            {
                if( c == '-' )
                {
                    exp << c;
                    part = SciPart::expSign;
                }
                else if( std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    part = SciPart::expInt;
                    exp << c;
                }
                else
                {
                    return false;
                }
            }
            else if( part == SciPart::expSign )
            {
                if( !std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    return false;
                }
                else
                {
                    part = SciPart::expInt;
                    exp << c;
                }
            }
            else if( part == SciPart::expInt )
            {
                if( !std::isdigit( static_cast<unsigned char>( c ) ) )
                {
                    return false;
                }
                else
                {
                    exp << c;
                }
            }
            else
            {
                return false;
            }
        }

        const std::string b = base.str();
        const std::string e = exp.str();
        
        if( b.empty() )
        {
            return false;
        }

        if( e.empty() )
        {
            // optimization, this is probably a decimal number so we will handle it
            const double shortcutDouble = std::stod( b );
            outVal = shortcutDouble;
            return true;
        }
        
        const double baseDouble = std::stod( b );
        const double expDouble = std::stod( e );
        const double multDouble = std::pow( 10.0, expDouble );
        const double valueDouble = baseDouble * multDouble;
        outVal = valueDouble;
        return true;
    }

void sharedstringlist_destroy (struct sharedstringlist* sharedstrings)
{
  if (sharedstrings) {
    size_t i;
    for (i = 0; i < sharedstrings->numstrings; i++)
      free(sharedstrings->strings[i]);
    free(sharedstrings->strings); // this should be added otherwise memory leaked
    free(sharedstrings);
  }
}

std::string analyze(path filename)
{
	int c = 0;
	xlsxioreader reader;
	std::string result;

	reader = xlsxioread_open(filename.string().c_str());
	if (reader == NULL)
	{
		std::cout << stderr << " error opening file " << filename << std::endl;
		return result;
	}

	xlsxioreadersheetlist sheetlist;
	if ((sheetlist = xlsxioread_sheetlist_open(reader)) != NULL)
	{
		while ((xlsxioread_sheetlist_next(sheetlist)) != NULL)
		{
			c++;
		}
		xlsxioread_sheetlist_close(sheetlist);
		std::cout << filename.string() << " contains " << c << " sheets" << std::endl;
	}
	return result;
}

<si>
    <t>共通</t>
    <rPh sb="0" eb="2"><t>キョウツウ</t></rPh>
    <phoneticPr fontId="4"/>
</si>

              // prevent the endless loop
              int looperx = 0;
              for( looperx = 0; looperx < fileindex && status == UNZ_OK; ++looperx ) {
                  status = unzGoToNextFile(data->zip);
              }

//callback function definition for use with iterate_files_by_contenttype
typedef void (*contenttype_file_callback_fn)(ZIPFILETYPE* zip, const XML_Char* filename, const XML_Char* contenttype, void* callbackdata);

struct iterate_files_by_contenttype_callback_data {
  ZIPFILETYPE* zip;
  const XML_Char* contenttype;
  contenttype_file_callback_fn filecallbackfn;
  void* filecallbackdata;
    bool doFindRelsFirst;
};

//expat callback function for element start used by iterate_files_by_contenttype
void iterate_files_by_contenttype_expat_callback_element_start (void* callbackdata, const XML_Char* name, const XML_Char** atts)
{
  struct iterate_files_by_contenttype_callback_data* data = (struct iterate_files_by_contenttype_callback_data*)callbackdata;
  if (XML_Char_icmp(name, X("Override")) == 0) {
    //explicitly specified file
    const XML_Char* contenttype;
    const XML_Char* partname;
    if ((contenttype = get_expat_attr_by_name(atts, X("ContentType"))) != NULL && XML_Char_icmp(contenttype, data->contenttype) == 0) {
      if ((partname = get_expat_attr_by_name(atts, X("PartName"))) != NULL) {
        if (partname[0] == '/')
          partname++;
        data->filecallbackfn(data->zip, partname, contenttype, data->filecallbackdata);
      }
    }
  } else if (XML_Char_icmp(name, X("Default")) == 0) {
    //by extension
    const XML_Char* contenttype;
    const XML_Char* extension;
    if ((contenttype = get_expat_attr_by_name(atts, X("ContentType"))) != NULL && XML_Char_icmp(contenttype, data->contenttype) == 0) {
      if ((extension = get_expat_attr_by_name(atts, X("Extension"))) != NULL) {
//          if( data->doFindRelsFirst && XML_Char_icmp( X( "rels" ), extension ) != 0 )
//          {
//              extension = X("rels");
//              
//          }
        XML_Char* filename;
        size_t filenamelen;
        size_t extensionlen = XML_Char_len(extension);
#ifdef USE_MINIZIP
#define UNZIP_FILENAME_BUFFER_STEP 32
        char* buf;
        size_t buflen;
        int status;
unz_global_info zipglobalinfo;
unzGetGlobalInfo(data->zip, &zipglobalinfo);
        buf = (char*)malloc(buflen = UNZIP_FILENAME_BUFFER_STEP);
        status = unzGoToFirstFile(data->zip);
          
          // this loop is problematic
          
          int fileindex = 0;
        while (status == UNZ_OK) {
          buf[buflen - 1] = 0;
        unz_file_info* finfo = malloc(sizeof(unz_file_info));
            
            // this was previously crashing because we were passing NULL as the second argument
        while ((status = unzGetCurrentFileInfo(data->zip, finfo, buf, buflen, NULL, 0, NULL, 0)) == UNZ_OK && buf[buflen - 1] != 0) {
            buflen += UNZIP_FILENAME_BUFFER_STEP;
            buf = (char*)realloc(buf, buflen);
            buf[buflen - 1] = 0;
          }
            free(finfo);
            finfo = NULL;

            if (status != UNZ_OK) {
            break;
            }
          filename = XML_Char_dupchar(buf);
          status = unzGoToNextFile(data->zip);
            ++fileindex;
//            unz64_s* s = (unz64_s*)data->zip;
//            ZPOS64_T currnumfile = s->num_file;
#else
        zip_int64_t i;
        zip_int64_t zipnumfiles = zip_get_num_entries(data->zip, 0);
        for (i = 0; i < zipnumfiles; i++) {
          filename = XML_Char_dupchar(zip_get_name(data->zip, i, ZIP_FL_ENC_GUESS));
#endif
          filenamelen = XML_Char_len(filename);
            
            // if the extension is a match
          if (filenamelen > extensionlen && filename[filenamelen - extensionlen - 1] == '.' && XML_Char_icmp(filename + filenamelen - extensionlen, extension) == 0) {
            
              // this call causes data->zip->num_file to revert to zero causing an endless loop?
              data->filecallbackfn(data->zip, filename, contenttype, data->filecallbackdata);
              
              // prevent the endless loop
              int looperx = 0;
              for( looperx = 0; looperx < fileindex && status == UNZ_OK; ++looperx ) {
                  status = unzGoToNextFile(data->zip);
              }
          }
          free(filename);
        }
#ifdef USE_MINIZIP
        free(buf);
#endif
      } // while (status == UNZ_OK)
    }
  }
}