doc_lang.cpp

Go to the documentation of this file.

/************************************************************************
 ************************************************************************
 FAUST compiler
 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
 ---------------------------------------------------------------------
 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 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, write to the Free Software
 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 ************************************************************************
 ************************************************************************/


#include <iostream>
#include <fstream>
#include <set>
#include <string>
#include <time.h>
#include <cstdlib>
#include <errno.h>

#include "doc_lang.hh"
#include "doc_notice.hh"
#include "doc_autodoc.hh"
#include "doc_metadatas.hh"
#include "lateq.hh"
#include "enrobage.hh"
#include "compatibility.hh"



extern map<string, string>  gDocNoticeStringMap;
extern set<string>          gDocNoticeKeySet;

extern map<string, string>  gDocAutodocStringMap;
extern set<string>          gDocAutodocKeySet;

extern map<string, string>  gDocMathStringMap;
extern set<string>          gDocMathKeySet;

extern map<string, string>  gDocMetadatasStringMap;
extern set<string>          gDocMetadatasKeySet;

static const string         gDocTextsDefaultFile = "mathdoctexts-default.txt";

static void         importDocStrings(const string& filename);
static void         getKey(string& s, string& key, size_t& pt1);
static void         getText(string& s, size_t& pt1, string& text);
static void         storePair(const string& key, const string& text);

static void         printStringMapContent(map<string,string>& map, const string& name);

static istream*     openArchFile (const string& filename);
static void         getCurrentDir();
static int          cholddir();

static string       gCurrentDir;    




/*****************************************************************************
                            Public functions
 *****************************************************************************/


void loadTranslationFile(const string& lang)
{
    initDocMath();
    initDocNotice();
    initDocAutodoc();
    initDocMetadatas();
    
    importDocStrings(gDocTextsDefaultFile);
    
    if ( ! lang.empty() ) {
        importDocStrings( "mathdoctexts-" + lang + ".txt" );
    }
}



/*****************************************************************************
                                Static functions
 *****************************************************************************/



static void importDocStrings(const string& filename)
{   
    string s;
    string key, text;
    istream* file = openArchFile(filename);
    
    while ( getline(*file, s) ) {
        size_t pt1; // Text pointer.
        
        /* The first character determines whether will follow a key or a text. */
        switch (s[0]) {
            case ':':
                text = "";
                getKey(s, key, pt1);
                if (pt1==string::npos) continue;
                break;
            case '\"':
                pt1 = 0;
                break;
            default:
                continue;
        }
        getText(s, pt1, text);
        storePair(key, text);
    }
    printStringMapContent(gDocNoticeStringMap, "gDocNoticeStringMap");
    printStringMapContent(gDocAutodocStringMap, "gDocAutodocStringMap");
    printStringMapContent(gDocMathStringMap, "gDocMathStringMap");
    printStringMapContent(gDocMetadatasStringMap, "gDocMetadatasStringMap");
}


static void getKey(string& s, string& key, size_t& pt1) 
{
    /* Initialisation. */
    key = "";
    string separators = " \t";
    size_t pk1 = 1;
    size_t pk2 = s.find_first_of(separators);
    
    /* Immediate '\n' after keyword case. */
    if (pk2==string::npos) pk2 = s.size();
    
    /* Capture and check the keyword. */
    key = s.substr(pk1, pk2-1);
    
    /* Prepare text capture. */
    pt1 = s.find_first_of("\"", pk2);
}


static void getText(string& s, size_t& pt1, string& text)
{
    /* Capture the text on the current line. */
    size_t pt2;
    pt2 = s.find_last_not_of("\"");
    if (pt2!=string::npos) {
        if (text.size() > 0) text += "\n"; // Handle line breaks.
        text += s.substr(pt1+1, pt2-pt1);
    }
}


static void storePair(const string& key, const string& text)
{
    /* Store the current pair. */
    if(!key.empty() && !text.empty()) {
        
        if (gDocNoticeKeySet.find(key) != gDocNoticeKeySet.end()) {
            gDocNoticeStringMap[key] = text;
        } 
        else if (gDocAutodocKeySet.find(key) != gDocAutodocKeySet.end()) {
            gDocAutodocStringMap[key] = text;
        }
        else if (gDocMathKeySet.find(key) != gDocMathKeySet.end()) {
            gDocMathStringMap[key] = text;
        }
        else if (gDocMetadatasKeySet.find(key) != gDocMetadatasKeySet.end()) {
            gDocMetadatasStringMap[key] = text;
        }
        else {
            cerr << "Documentator : importDocStings : " << "warning : unknown key \"" << key << "\"" << endl;
        }
        //cerr << "gDocNoticeStringMap[\"" << key << "\"] = \"" << gDocNoticeStringMap[key] << "\"" << endl;
    }
}


static void printStringMapContent(map<string,string>& m, const string& name) {
    bool trace = false;
    if(trace) {
        cout << name << ".size() = " << m.size() << endl;
        map<string,string>::iterator it;
        int i = 1;
        for(it = m.begin(); it!=m.end(); ++it)
            cout << i++ << ".\t" << name << "[" << it->first << "] \t= '" << it->second << "'" << endl;
    }
}




//------------------------ file managment -------------------------


static istream* openArchFile (const string& filename)
{
    istream* file;
    getCurrentDir();    // Save the current directory.
    if ( (file = open_arch_stream(filename.c_str())) ) {
        //cerr << "Documentator : openArchFile : Opening '" << filename << "'" << endl;
    } else {
        cerr << "ERROR : can't open architecture file " << filename << endl;
        exit(1);
    }
    cholddir();         // Return to current directory.
    return file;
}


static int cholddir ()
{
    if (chdir(gCurrentDir.c_str()) == 0) {
        return 0;
    } else {
        perror("cholddir");
        exit(errno);
    }
}


static void getCurrentDir ()
{
    char    buffer[FAUST_PATH_MAX];
    gCurrentDir = getcwd (buffer, FAUST_PATH_MAX);
}