Can't Compile a code!!! I ran into "undefined reference to" error.

hi i use cyqwin machine and i am new in linux. i can not compile a code i ran into these errors:

ngram-count.o:ngram-count.cc: (.text+0xa9): undefined reference to `_Opt_Parse'
ngram-count.o:ngram-count.cc: (.text+0x11f): undefined reference to `Vocab::Vocab(unsigned int, unsigned int)'
ngram-count.o:ngram-count.cc: (.text+0x204): undefined reference to `SubVocab::SubVocab(Vocab&)'
ngram-count.o:ngram-count.cc: (.text+0x245): undefined reference to `StopNgramStats::StopNgramStats(Vocab&, SubVocab&, unsigned int)'
ngram-count.o:ngram-count.cc: (.text+0x2b5): undefined reference to `File::File(char const*, char const*, int)'
ngram-count.o:ngram-count.cc: (.text+0x2f7): undefined reference to `File::~File()'
ngram-count.o:ngram-count.cc: (.text+0x31f): undefined reference to `File::File(char const*, char const*, int)'

..........................
I checked the include addresses in makefile and all are right.
can anybody help me and give me some tips?

Thanks

You need to make sure you are compiling all the source files, and then linking together the .o files. So either you've got all the files, and just never bothered to write those six functions, or you are missing the file that contains those functions.

Looks like this ngram-count program is from somewhere on the internet, perhaps the OP didn't write this code.

Can you show more output? What make command are you running precisely? Where did you get this source code if you didn't write it yourself?

you know I download the code from a scientific site that it is free license.

Here is the link:

http://userver.ftw.at/~pucher/semanlm/semanlm0.91.zip

if it is useful.

Here is my make file if you are interested:

#
# Makefile
#

PROGS= ngram-count trainmodel lsalm
CXX = g++
#for compiling C files
CC = cc


#change the following variable: tcl library
TCLLIB=/usr/share/tcllib1.13


MACHINE_TYPE=i686
INCLUDE_DIR=../include
LIB_DIR=../lib
SRC_DIR=./
#ALL_INCLUDES = -I./ -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/srilm
ALL_INCLUDES = -I./ -I$(INCLUDE_DIR)
ALL_LIBRARIES = -lm -L$(LIB_DIR)/$(MACHINE_TYPE) -llattice -lflm -loolm -ldstruct -lmisc

CXXFLAGS = -O3 -Wno-deprecated


################################################## #########################

OBJ_LSALM=lsalm.o LsaNgram.o LsaLM.o LsaFile.o
OBJ_MIPLSA = trainmodel.o miplsa.o tools.o writeModel.o option.o las2.o LsaFile.o
OBJ_READMATRIX=ngram-count.o

all : $(PROGS)

.PHONY : all

lsalm: $(OBJ_LSALM)
$(CXX) -o $@ $(OBJ_LSALM) $(ALL_LIBRARIES) $(CXXFLAGS)

ngram-count: $(OBJ_READMATRIX)
$(CXX) -o $@ $(OBJ_READMATRIX) $(ALL_LIBRARIES) $(CXXFLAGS)

trainmodel: $(OBJ_MIPLSA)
$(CXX) -o $@ $(OBJ_MIPLSA) $(ALL_LIBRARIES)


$(SRC_DIR)%.o: $(SRC_DIR)%.cpp
cd $(SRC_DIR) && $(CXX) -c $(CXXFLAGS) $(ALL_INCLUDES) $*.cpp

$(SRC_DIR)%.o: $(SRC_DIR)%.cc
cd $(SRC_DIR) && $(CXX) -c $(CXXFLAGS) $(ALL_INCLUDES) $*.cc

$(SRC_DIR)%.o: $(SRC_DIR)%.c
cd $(SRC_DIR) && $(CC) -c $(ALL_INCLUDES) $*.c

################################################## #####################

clean:
rm -f *.o $(PROGS)
--------------------------------------------------------------

I download tcllib library from http://sourceforge.net/projects/tcll...s/tcllib/1.13/
and i install it with this command tclsh installer.tcl

the installer copies to these directories:
packages ----> C:/cygwin/usr/share/tcllib1.13
applications---->C:/cygwin/usr/bin

I think the compiler doesn't reach to that stage to use tcllib and before that compiler stops because i omit the TCLLIB=/usr/share/tcllib1.13 line and still it has those errors.

I write this command to see the errors "make > make.txt 2>&1" and it prints the process to make.txt and the errors are the same.

here is the errors that i found in make.txt :

g++ -o ngram-count ngram-count.o -lm -L../lib/i686 -llattice -lflm -loolm -ldstruct -lmisc -O3 -Wno-deprecated
ngram-count.o:ngram-count.cc: (.text+0xa9): undefined reference to `_Opt_Parse'
ngram-count.o:ngram-count.cc: (.text+0x11f): undefined reference to `Vocab::Vocab(unsigned int, unsigned int)'
ngram-count.o:ngram-count.cc: (.text+0x204): undefined reference to `SubVocab::SubVocab(Vocab&)'
ngram-count.o:ngram-count.cc: (.text+0x245): undefined reference to `StopNgramStats::StopNgramStats(Vocab&, SubVocab&, unsigned int)'
ngram-count.o:ngram-count.cc: (.text+0x2b5): undefined reference to `File::File(char const*, char const*, int)'
ngram-count.o:ngram-count.cc: (.text+0x2f7): undefined reference to `File::~File()'
ngram-count.o:ngram-count.cc: (.text+0x31f): undefined reference to `File::File(char const*, char const*, int)'
ngram-count.o:ngram-count.cc: (.text+0x339): undefined reference to `File::~File()'
ngram-count.o:ngram-count.cc: (.text+0x36e): undefined reference to `SubVocab::SubVocab(Vocab&)'
ngram-count.o:ngram-count.cc: (.text+0x38f): undefined reference to `File::File(char const*, char const*, int)'
ngram-count.o:ngram-count.cc: (.text+0x39b): undefined reference to `Vocab::read(File&)'
ngram-count.o:ngram-count.cc: (.text+0x3c7): undefined reference to `File::~File()'
ngram-count.o:ngram-count.cc: (.text+0x3d1): undefined reference to `vtable for Vocab'
ngram-count.o:ngram-count.cc: (.text+0x3d9): undefined reference to `LHash<unsigned int, unsigned int>::~LHash()'
ngram-count.o:ngram-count.cc: (.text+0x3e4): undefined reference to `LHash<unsigned int, unsigned int>::~LHash()'
ngram-count.o:ngram-count.cc: (.text+0x3fe): undefined reference to `LHash<char const*, unsigned int>::~LHash()'

.
.
.
and so on.

Compiling this program is very important to me I dont know how to work with linux codes. could you please help me to compile these codes.

Thanks alot

my mail address is mybb30 AT yahoo dot com

Code:

---

OBJ_READMATRIX=ngram-count.o

---

I don't feel like downloading the package -- but there's only one source file in the package? Are you sure?

yes I am sure about that. in src folder there are 18 c files and 8 .h files.
I am getting confused. I dont know what to do. i dont know where is the error? maybe my cygwin has some parameters that i must change them.

So why didn't you list the 18 source files where you're supposed to list them (in the line I quoted above)?

you are right but I don't know where and how to list them in my make file? I know nothing about linux and makefiles. :frown:

Quote:

---

Originally Posted by andereasmehdi

you are right but I don't know where and how to list them in my make file? I know nothing about linux and makefiles. :frown:

---

It's never to late to learn ;)

GNU `make'

Hopefully you know something about programming and compiling...

Quote:

---

Originally Posted by andereasmehdi

you are right but I don't know where and how to list them in my make file? I know nothing about linux and makefiles. :frown:

---

That's why I quoted the list you had of them, with only one file in it. Surely you can take that one file into more than one file?

hi
@MK27: thanks for your helpful links. But MK27 i don't want to learn C++, also it has not syntactic error. I don't know how to compile C++ in Cygwin.
@tabstop: I changed Opt_Parse(argc, argv, options, Opt_Number(options), 0); to std::Opt_Parse(argc, argv, options, Opt_Number(options), 0); and it works!!!
I skip those errors. and these are new one :confused:

g++ -g -O3 -Wno-deprecated -c -o ngram-count.o ngram-count.cc
In file included from ngram-count.cc:17:
option.h:25:24: error: cfuncproto.h: No such file or directory
ngram-count.cc:18:18: error: File.h: No such file or directory
ngram-count.cc:19:19: error: Vocab.h: No such file or directory
ngram-count.cc:20:22: error: SubVocab.h: No such file or directory
ngram-count.cc:21:19: error: Ngram.h: No such file or directory
ngram-count.cc:22:22: error: VarNgram.h: No such file or directory
ngram-count.cc:23:25: error: TaggedNgram.h: No such file or directory
ngram-count.cc:24:23: error: SkipNgram.h: No such file or directory
ngram-count.cc:25:23: error: StopNgram.h: No such file or directory
ngram-count.cc:26:24: error: NgramStats.h: No such file or directory
ngram-count.cc:27:30: error: TaggedNgramStats.h: No such file or directory


i checked the ALL_INCLUDES = -I./ -I$(INCLUDE_DIR) -I$(INCLUDE_DIR)/srilm and it is were my headers are there.

hi tabstop, thanks for your useful tips. I understand you a little now. i changed OBJ_READMATRIX= ngram-count.o to OBJ_READMATRIX= Vocab.o option.o ngram-count.o and it works! I mean one of the errors get lost.
But you know I ran into another one. here is error:
Vocab.cc: In member function `VocabIndex Vocab::metaTagOfType(unsigned int)': Vocab.cc:253: error: expected primary-expression before "char".

here is my Vocab.h:

Code:

---

/*
 * Vocab.h --
 *        Interface to the Vocab class.
 *
 *
 * SYNOPSIS
 *
 * Vocab represents sets of string tokens as typically used for vocabularies,
 * word class names, etc.  Additionally, Vocab provides a mapping from
 * such string tokens (type VocabString) to integers (type VocabIndex).
 * VocabIndex is typically used to index words in language models to
 * conserve space and speed up comparisons etc.  Thus, Vocab essentially
 * implements a symbol table into which strings can be "interned."
 *
 * INTERFACE
 *
 * VocabIndex(VocabIndex start, VocabIndex end)
 *        Initializes a Vocab and sets the index range.
 *        Indices are allocated starting at start and incremented from there.
 *        No indices are allowed beyond end.
 *        This provides a way to map several distinct Vocabs to disjoint
 *        ranges of integers, and then use them jointly without danger of
 *        confusion.
 *
 * VocabIndex addWord(VocabString token)
 *        Adds a new string to the Vocab, returning the assigned index,
 *        or looks up the index if the token already exists.
 *
 * VocabString getWord(VocabIndex index)
 *        Returns the string token associated with index, or 0 if it none
 *        exists.
 *
 * VocabIndex getIndex(VocabString token)
 *        Returns the index for a string token, or Vocab_None if none exists.
 *
 * void remove(VocabString token)
 * void remove(VocabIndex index)
 *        Deletes an item from the Vocab, either by token or by index.
 *
 * unsigned int numWords()
 *        Returns the number of tokens (and indices) in the Vocab.
 *
 * VocabIndex highIndex()
 *        Returns the highest word index in use, or Vocab_None if
 *        vocabulary is empty.
 *
 * ITERATION
 *
 * VocabIter implements iterations over Vocabs.
 *
 * VocabIter(Vocab &vocab)
 *        Creates and initializes an iteration over vocab.
 *
 * void init()
 *        Reset an iteration to the "first" element.
 *
 * VocabString next()
 * VocabString next(VocabIndex &index)
 *        Returns the next Vocab token in an iteration, or 0 if the
 *        iteration is finished.  index is set to the corresponding
 *        index.
 *
 * unsigned int read(File &file)
 *        Read a word list from a file into the Vocab, implicitly performing
 *        an addWord() on each token read.  Returns the number of tokens read.
 *
 * void write(File &file)
 *        Write the current set of word tokes to a file, in random order.
 *
 * NOTE: While an iteration over a Vocab is ongoing, no modifications
 * are allowed to the Vocab, EXCEPT possibly removal of the
 * "current" token/index.
 *
 * An iteration returns the elements of a Vocab in random, but deterministic
 * order. Furthermore, when copied or used in initialization of other objects,
 * VocabIter objects retain the current "position" in an iteration.  This
 * allows nested iterations that enumerate all pairs of distinct elements.
 *
 * Copyright (c) 1995-2010 SRI International.  All Rights Reserved.
 *
 * @(#)$Header: /home/srilm/devel/lm/src/RCS/Vocab.h,v 1.41 2010/06/02 05:49:58 stolcke Exp $
 *
 */

#ifndef _Vocab_h_
#define _Vocab_h_

#ifdef PRE_ISO_CXX
# include <iostream.h>
#else
# include <iostream>
using namespace std;
#endif

#include "Boolean.h"
#include "File.h"
#include "LHash.h"
#include "SArray.h"
#include "Array.h"
#include "MemStats.h"

#ifdef USE_SHORT_VOCAB
typedef unsigned short        VocabIndex;
#else
typedef unsigned int        VocabIndex;
#endif
typedef const char        *VocabString;

const unsigned int        maxWordLength = 1024;

const VocabIndex        Vocab_None = (VocabIndex)-1;

const VocabString        Vocab_Unknown = "<unk>";
const VocabString        Vocab_SentStart = "<s>";
const VocabString        Vocab_SentEnd = "</s>";
const VocabString        Vocab_Pause = "-pau-";

typedef int (*VocabIndexComparator)(VocabIndex, VocabIndex);
typedef int (*VocabIndicesComparator)(const VocabIndex *, const VocabIndex *);

class Vocab
{
    friend class VocabIter;

public:
    Vocab(VocabIndex start = 0, VocabIndex end = (Vocab_None-1));
    virtual ~Vocab() {};

    virtual VocabIndex addWord(VocabString name);
    virtual VocabIndex addWordAlias(VocabIndex word, VocabString name);
    virtual VocabString getWord(VocabIndex index);
    virtual VocabIndex getIndex(VocabString name,
                                    VocabIndex unkIndex = Vocab_None);
    virtual void remove(VocabString name);
    virtual void remove(VocabIndex index);
    virtual unsigned int numWords() const { return byName.numEntries(); };
    virtual VocabIndex highIndex() const;

    /*
    * Special (pseudo-) vocabulary tokens
    */
    virtual VocabIndex &unkIndex() { return _unkIndex; };  /* <unk> index */
    virtual VocabIndex &ssIndex() { return _ssIndex; };          /* <s> index */
    virtual VocabIndex &seIndex() { return _seIndex; };          /* </s> index */
    virtual VocabIndex &pauseIndex() { return _pauseIndex; }; /* -pau- index */

    virtual Boolean &unkIsWord() { return _unkIsWord; };
                                        /* consider <unk> a regular word */

    virtual Boolean &toLower() { return _toLower; };
                                        /* map word strings to lowercase */

    /*
    * Some Vocab tokens/indices are "pseudo words", i.e., they don't
    * get probabilities since they can only occur in contexts.
    */
    virtual Boolean isNonEvent(VocabString word)        /* pseudo-word? */
        { return isNonEvent(getIndex(word)); };
    virtual Boolean isNonEvent(VocabIndex word) const        /* non-event? */
        { return (!_unkIsWord && (word == _unkIndex)) ||
                nonEventMap.find(word) != 0; };

    virtual VocabIndex addNonEvent(VocabIndex word);
    virtual VocabIndex addNonEvent(VocabString name)
        { return addNonEvent(addWord(name)); };
    virtual Boolean addNonEvents(Vocab &nonevents);
    virtual Boolean removeNonEvent(VocabIndex word);

    /*
    * Handling of meta-count tags: these are tags that represent a token
    * count total, or a type frequency count (count-of-count).
    * If metaTag == "__META__", the following tags acquire special meaning:
    *
    *        __META__                a word count total
    *        __META__1                count of singleton word types
    *        __META__2                count of word types occurring twice
    *        ...                        ...
    *        __META__N                count of word types occurring N times
    */
    virtual VocabString &metaTag() { return _metaTag; }; /* meta-count tag */
    Boolean isMetaTag(VocabIndex word)
        { return metaTagMap.find(word) != 0; };
    unsigned typeOfMetaTag(VocabIndex word)
        { unsigned *type = metaTagMap.find(word);
          return type != 0 ? *type : (unsigned)-1; };
    VocabIndex metaTagOfType(unsigned);

    /*
    * Utilities for handling Vocab sequences
    */
    virtual unsigned int getWords(const VocabIndex *wids,
                          VocabString *words, unsigned int max);
    virtual unsigned int addWords(const VocabString *words,
                          VocabIndex *wids, unsigned int max);
    virtual unsigned int getIndices(const VocabString *words,
                            VocabIndex *wids, unsigned int max,
                            VocabIndex unkIndex = Vocab_None);
    virtual Boolean checkWords(const VocabString *words,
                              VocabIndex *wids, unsigned int max);
    static unsigned int parseWords(char *line,
                                  VocabString *words, unsigned int max);

    static unsigned int length(const VocabIndex *words);
    static unsigned int length(const VocabString *words);
    static VocabIndex *copy(VocabIndex *to, const VocabIndex *from);
    static VocabString *copy(VocabString *to, const VocabString *from);
    static VocabIndex *reverse(VocabIndex *words);
    static Boolean contains(const VocabIndex *words, VocabIndex word);
    static VocabString *reverse(VocabString *words);
    static void write(File &file, const VocabString *words);

    /*
    *  Comparison of Vocabs and their sequences
    */
    static int compare(VocabIndex word1, VocabIndex word2);
                                /* order on word indices induced by Vocab */
    static int compare(VocabString word1, VocabString word2)
        { return strcmp(word1, word2); };
    static int compare(const VocabIndex *word1, const VocabIndex *word2);
                                /* order on word index sequences */
    static int compare(const VocabString *word1, const VocabString *word2);

    VocabIndexComparator compareIndex() const;
    VocabIndicesComparator compareIndices() const;
    Boolean ngramsInRange(VocabString *startRange, VocabString *endRange);

    /*
    * Miscellaneous
    */
    virtual unsigned int read(File &file);
    virtual unsigned int readAliases(File &file);
    virtual void write(File &file, Boolean sorted = true) const;
    virtual void use() const { outputVocab = (Vocab *)this; }; // discard const

    virtual Boolean readIndexMap(File &file, Array<VocabIndex> &map,
                                                Boolean limitVocab = false);
    virtual void writeIndexMap(File &file);

    virtual void memStats(MemStats &stats) const;

    static Vocab *outputVocab;  /* implicit parameter to operator<< */

    static Vocab *compareVocab;        /* implicit parameter to compare() */
protected:
    LHash<VocabString,VocabIndex> byName;
    Array<VocabString> byIndex;
    VocabIndex nextIndex;
    VocabIndex maxIndex;

    LHash<VocabIndex, unsigned> nonEventMap;        /* set of non-event words */
    LHash<VocabIndex, unsigned> metaTagMap;        /* maps metatags to their type:
                                                  0        count total
                                                  1        single counts
                                                  ...
                                                  N        count of count N */

    // hidden data members (accessed through virtual functions
    VocabIndex _unkIndex;                /* <unk> index */
    VocabIndex _ssIndex;                /* <s> index */
    VocabIndex _seIndex;                /* </s> index */
    VocabIndex _pauseIndex;                /* -pau- index */
    Boolean _unkIsWord;                        /* consider <unk> a regular word */
    Boolean _toLower;                        /* map word strings to lowercase */
    VocabString _metaTag;                /* meta-count tag */
};

ostream &operator<< (ostream &, const VocabString *words);
ostream &operator<< (ostream &, const VocabIndex *words);

class VocabIter
{
public:
    VocabIter(const Vocab &vocab, Boolean sorted = false);
    void init();
    VocabString next() { VocabIndex index; return next(index); };
    VocabString next(VocabIndex &index);
private:
    LHa........er<VocabString,VocabIndex> myIter;
};

/*
 * We sometimes use strings over VocabIndex as keys into maps.
 * Define the necessary support functions (see Map.h, LHash.cc, SArray.cc).
 */
static inline unsigned
LHash_hashKey(const VocabIndex *key, unsigned maxBits)
{
    unsigned i = 0;

    /*
    * The rationale here is similar to LHash_hashKey(unsigned),
    * except that we shift more to preserve more of the typical number of
    * bits in a VocabIndex.  The value was optimized to encoding 3 words
    * at a time (trigrams).
    */
    for (; *key != Vocab_None; key ++) {
        i += (i << 12) + *key;
    }
    return LHash_hashKey(i, maxBits);
}

static inline const VocabIndex *
Map_copyKey(const VocabIndex *key)
{
    VocabIndex *copy = new VocabIndex[Vocab::length(key) + 1];
    assert(copy != 0);

    unsigned i;
    for (i = 0; key[i] != Vocab_None; i ++) {
        copy[i] = key[i];
    }
    copy[i] = Vocab_None;

    return copy;
}

static inline void
Map_freeKey(const VocabIndex *key)
{
    delete [] (VocabIndex *)key;
}

static inline Boolean
LHash_equalKey(const VocabIndex *key1, const VocabIndex *key2)
{
    unsigned i;
    for (i = 0; key1[i] != Vocab_None && key2[i] != Vocab_None; i ++) {
        if (key1[i] != key2[i]) {
            return false;
        }
    }
    if (key1[i] == Vocab_None && key2[i] == Vocab_None) {
        return true;
    } else {
        return false;
    }
}
   
static inline int
SArray_compareKey(const VocabIndex *key1, const VocabIndex *key2)
{
    unsigned int i = 0;

    for (i = 0; ; i++) {
        if (key1[i] == Vocab_None) {
            if (key2[i] == Vocab_None) {
                return 0;
            } else {
                return -1;        /* key1 is shorter */
            }
        } else {
            if (key2[i] == Vocab_None) {
                return 1;        /* key2 is shorted */
            } else {
                int comp = SArray_compareKey(key1[i], key2[i]);
                if (comp != 0) {
                    return comp;        /* they differ at pos i */
                }
            }
        }
    }
    /*NOTREACHED*/
}

#endif /* _Vocab_h_ */

---

Thanks for your tips. but It takes a while to me to understand it. so I already Thank for everything.

Quote:

---

But you know I ran into another one. here is error:
Vocab.cc: In member function `VocabIndex Vocab::metaTagOfType(unsigned int)': Vocab.cc:253: error: expected primary-expression before "char".

---

And we're supposed to be psychic and know what line 253 of Vocab.cc contains?

Code:

---

LHa........er<VocabString,VocabIndex> myIter;

---

LOL...pwn3d by the filter!

LOL ;)

Here is the Line that makes the error:

Code:

---

makeArray(char, tagName, strlen(_metaTag) + 20);

---

I know that we can not pass a type as an argument but I don't know maybe it is a macro or something :confused:
I checked all the files but there is no definition for makeArray I am confused.
all files just use makeArray !!!
maybe you want to see Array.cc:

Code:

---

/*
 * Array.cc --
 *        Extensible array implementation
 *
 */

#ifndef _Array_cc_
#define _Array_cc_

#ifndef lint
static char Array_Copyright[] = "Copyright (c) 1995,1997 SRI International.  All Rights Reserved.";
static char Array_RcsId[] = "@(#)$Header: /home/cvsb2/semanlm/include/srilm/Array.cc,v 1.1 2006/01/12 14:48:17 pucher Exp $";
#endif

#include <assert.h>
#include <stdlib.h>
#include <string.h>

#include "C:\cygwin\semanlm\include\srilm\Array.h"

#undef INSTANTIATE_ARRAY
#define INSTANTIATE_ARRAY(DataT) \
        template class Array<DataT>

/*
 * extend the size of an Array to accomodate size elements
 *        Note we want to zero-initialize the data elements by default,
 *        so we call their initializers with argument 0.  This means
 *        that all data type used as arguments to the Array template
 *        need to provide an initializer that accepts 0 as a single argument.
 */
template <class DataT>
void
Array<DataT>::alloc(unsigned int size)
{
    unsigned int newSize = size + 1 + alloc_size/2;
    DataT *newData = new DataT[newSize];
    assert(newData != 0);

#ifdef ZERO_INITIALIZE
    memset(newData, 0, newSize * sizeof(DataT));
#endif

    for (unsigned i = 0; i < alloc_size; i++) {
        newData[i] = _data[i];
    }

    delete [] _data;

    _data = newData;
    alloc_size = newSize;
}

template <class DataT>
void
Array<DataT>::memStats(MemStats &stats) const
{
    stats.total += _size * sizeof(_data[0]);
    stats.wasted += (alloc_size - _size) * sizeof(_data[0]);
}

template <class DataT>
Array<DataT> &
Array<DataT>::operator= (const Array<DataT> &other)
{
    // cerr << "warning: Array::operator= called\n";

    if (&other == this) {
        return *this;
    }

    delete [] _data;

    _base = other._base;
    _size = other._size;
    alloc_size = other.alloc_size;

    _data = new DataT[alloc_size];
    assert(_data != 0);

#ifdef ZERO_INITIALIZE
    memset(_data, 0, alloc_size * sizeof(DataT));
#endif

    for (unsigned i = 0; i < alloc_size; i++) {
        _data[i] = other._data[i];
    }

    return *this;
}

#endif /* _Array_cc_ */

---

Also being tended to here

:biggrin: LOL

hi
"makeArray" is a macro in the dstruct/src/Array.h file from the SRI sources. and replacing the file fixed it.

I changed the

Code:

---

OBJ_READMATRIX= LHash.o Map.o zio.o Array.o File.o Vocab.o option.o ngram-count.o

---

and the new ones appears:

Quote:

---

Vocab.o:Vocab.cc: .text$_ZN5LHashIjjE6removeEjRb[LHash<unsigned int, unsigned int>::remove(unsigned int, bool&)]+0xb): undefined reference to `LHash<unsigned int, unsigned int>::removedData'
Vocab.o:Vocab.cc: ).text$_ZN5LHashIjjE6removeEjRb[LHash<unsigned int, unsigned int>::remove(unsigned int, bool&)]+0x22): undefined reference to `LHash<unsigned int, unsigned int>::removedData'
Vocab.o:Vocab.cc: ).text$_ZN5LHashIjjE6removeEjRb[LHash<unsigned int, unsigned int>::remove(unsigned int, bool&)]+0x106): undefined reference to `LHash<unsigned int, unsigned int>::removedData'
Vocab.o:Vocab.cc: ).text$_ZN5LHashIjjE6removeEjRb[LHash<unsigned int, unsigned int>::remove(unsigned int, bool&)]+0x22b): undefined reference to `LHash<unsigned int, unsigned int>::removedData'

---

I copy the entire LHash.cc and I colorized the important lines for the error:

Code:

---

/*
 * LHash.cc --
 *    Linear search hash table implementation
 *
 */

#ifndef _LHash_cc_
#define _LHash_cc_

#ifndef lint
static char LHash_Copyright[] = "Copyright (c) 1995-2010 SRI International.  All Rights Reserved.";
static char LHash_RcsId[] = "@(#)$Header: /home/srilm/devel/dstruct/src/RCS/LHash.cc,v 1.53 2010/06/02 04:52:43 stolcke Exp $";
#endif

#ifdef PRE_ISO_CXX
# include <new.h>
# include <iostream.h>
#else
# include <new>
# include <iostream>
using namespace std;
#endif
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "C:\cygwin\semanlm\include\srilm\LHash.h"

#undef INSTANTIATE_LHASH
#define INSTANTIATE_LHASH(KeyT, DataT) \
    template <> DataT *LHash< KeyT, DataT >::removedData = 0; \
    template class LHash< KeyT, DataT >; \
    template class LHa........er< KeyT, DataT >

#ifndef __GNUG__
template <class KeyT, class DataT>
DataT *LHash<KeyT,DataT>::removedData = 0;
#endif /* __GNUG__ */

#ifdef DEBUG
template <class KeyT, class DataT>
unsigned long LHash<KeyT,DataT>::collisionCount = 0;
#endif

const unsigned minHashBits = 3;        /* minimum no. bits for hashing
                    * tables smaller than this use linear
                    * search to save space */
const float fillRatio = 0.8f;        /* fill ration at which the table is
                    * expanded and rehashed */

#define BODY(b)    ((LHashBody<KeyT,DataT> *)b)

/*
 * Dump the entire hash array to cerr.  Unused slots are printed as "FREE".
 */
template <class KeyT, class DataT>
void
LHash<KeyT,DataT>::dump() const
{
    if (body) {
    unsigned maxEntries = hashSize(BODY(body)->maxBits);
    unsigned i;

    for (i = 0; i < maxEntries; i++) {
        cerr << " " << i << ": ";
        if (Map_noKeyP(BODY(body)->data[i].key)) {
        cerr << "FREE";
        } else {
        cerr << BODY(body)->data[i].key
#ifdef DUMP_VALUES
            /*
            * Only certain types can be printed.
            */
            << "->" << BODY(body)->data[i].value
#endif /* DUMP_VALUES */
            ;
        }
    }
    } else {
    cerr << "EMPTY";
    }
    cerr << endl;
}

template <class KeyT, class DataT>
void
LHash<KeyT,DataT>::memStats(MemStats &stats) const
{
    stats.total += sizeof(*this);
    if (body) {
        unsigned maxEntries = hashSize(BODY(body)->maxBits);

    stats.total += sizeof(*BODY(body)) +
            sizeof(BODY(body)->data[0]) *
                (maxEntries - 1);
    stats.wasted += sizeof(BODY(body)->data[0]) *
                (maxEntries - BODY(body)->nEntries);
    }
}

/*
 * Compute the actual minimum size required for a given number of entries
 */
static inline unsigned
roundSize(unsigned size)
{
    if (size < hashSize(minHashBits)) {
    return size;
    } else {
    return (unsigned)((size + 1)/ fillRatio);
    }
}

template <class KeyT, class DataT>
void
LHash<KeyT,DataT>::alloc(unsigned size)
{
    unsigned maxBits, maxEntries;
    unsigned i;

    /*
    * round up to power of two
    */
    maxBits = 0;
    while (hashSize(maxBits) < size) {
    assert(maxBits < LHash_maxBitLimit);
    maxBits++;
    }

    maxEntries = hashSize(maxBits);

    //cerr << "LHash::alloc: current " << (body ? BODY(body)->nEntries : 0)
    //    << ", requested " << size
    //    << ", allocating " << maxEntries << " (" << maxBits << ")\n";

    body = (LHashBody<KeyT,DataT> *)malloc(sizeof(*BODY(body)) +
                  (maxEntries - 1) * sizeof(BODY(body)->data[0]));
    assert(body != 0);

    BODY(body)->maxBits = maxBits;
    BODY(body)->nEntries = 0;

    for (i = 0; i < maxEntries; i++) {
    Map_noKey(BODY(body)->data[i].key);
    }
    //cerr << "memory for header = " <<
    //        ((void *)&(BODY(body)->data[0]) - (void *)BODY(body)) << endl;
    //cerr << "memory per entry = " <<
    //        ((void *)&(BODY(body)->data[3]) - (void *)&(BODY(body)->data[2])) << endl;
}

template <class KeyT, class DataT>
LHash<KeyT,DataT>::LHash(unsigned size)
    : body(0)
{
    if (size != 0) {
    /*
    * determine actual initial size
    */
    alloc(roundSize(size));
    }
}

template <class KeyT, class DataT>
void
LHash<KeyT,DataT>::clear(unsigned size)
{
    if (body) {
    unsigned maxEntries = hashSize(BODY(body)->maxBits);
    unsigned i;

    for (i = 0; i < maxEntries; i++) {
        if (! Map_noKeyP(BODY(body)->data[i].key)) {
        Map_freeKey(BODY(body)->data[i].key);
        }
    }
    free(body);
    body = 0;
    }
    if (size != 0) {
    alloc(roundSize(size));
    }
}

template <class KeyT, class DataT>
void LHash<KeyT,DataT>::setsize(unsigned size)
{
    if (body == 0 && size != 0) {
    alloc(roundSize(size));
    }
}

template <class KeyT, class DataT>
LHash<KeyT,DataT>::~LHash()
{
    clear(0);
}

template <class KeyT, class DataT>
LHash<KeyT,DataT>::LHash(const LHash<KeyT,DataT> &source)
    : body(0)
{
#ifdef DEBUG
    cerr << "warning: LHash copy constructor called\n";
#endif
    *this = source;
}

template <class KeyT, class DataT>
LHash<KeyT,DataT> &
LHash<KeyT,DataT>::operator= (const LHash<KeyT,DataT> &other)
{
#ifdef DEBUG
    cerr << "warning: LHash::operator= called\n";
#endif

    if (&other == this) {
    return *this;
    }

    /*
    * copy hash entries from old to new
    */
    if (other.body) {
    unsigned maxEntries = hashSize(BODY(other.body)->maxBits);
    /*
    * ensure we have exactly the same size as source table
    */
    clear(0);
    alloc(maxEntries);

    for (unsigned i = 0; i < maxEntries; i++) {
        KeyT thisKey = BODY(other.body)->data[i].key;

        if (!Map_noKeyP(thisKey)) {
        /*
        * Copy key
        */
        BODY(body)->data[i].key = Map_copyKey(thisKey);

        /*
        * Initialize data, required for = operator
        */
        new (&(BODY(body)->data[i].value)) DataT;

        /*
        * Copy data
        */
        BODY(body)->data[i].value = BODY(other.body)->data[i].value;
        }
    }
    BODY(body)->nEntries = BODY(other.body)->nEntries;
    } else {
    clear(0);
    }

    return *this;
}

/*
 * Returns index into data array that has the key which is either
 * equal to key, or indicates the place where key would be placed if it
 * occurred in the array.
 */
template <class KeyT, class DataT>
Boolean
LHash<KeyT,DataT>::locate(KeyT key, unsigned &index) const
{
    assert(!Map_noKeyP(key));

    if (body) {
    unsigned maxBits = BODY(body)->maxBits;
        register MapEntry<KeyT,DataT> *data = BODY(body)->data;

    if (maxBits < minHashBits) {
        /*
        * Do a linear search
        */
        unsigned nEntries = BODY(body)->nEntries;
        register unsigned i;

        for (i = 0; i < nEntries; i++) {
        if (LHash_equalKey(data[i].key, key)) {
            index = i;
            return true;
        }
        }
        index = i;
        return false;
    } else {
        /*
        * Do a hashed search
        */
        unsigned hash = LHash_hashKey(key, maxBits);
        unsigned i;

        for (i = hash; ; i = (i + 1) & hashMask(maxBits))
        {
        if (Map_noKeyP(data[i].key)) {
            index = i;
            return false;
        } else if (LHash_equalKey(data[i].key, key)) {
            index = i;
            return true;
        }
#ifdef DEBUG
        collisionCount += 1;
#endif
        }
    }
    } else {
    return false;
    }
}

template <class KeyT, class DataT>
DataT *
LHash<KeyT,DataT>::find(KeyT key, Boolean &foundP) const
{
    unsigned index;

    if ((foundP = locate(key, index))) {
    return &(BODY(body)->data[index].value);
    } else {
    return 0;
    }
}

template <class KeyT, class DataT>
KeyT
LHash<KeyT,DataT>::getInternalKey(KeyT key, Boolean &foundP) const
{
    unsigned index;
    static KeyT zeroKey;

    if ((foundP = locate(key, index))) {
    return BODY(body)->data[index].key;
    } else {
    return zeroKey;
    }
}

template <class KeyT, class DataT>
DataT *
LHash<KeyT,DataT>::insert(KeyT key, Boolean &foundP)
{
    unsigned index;

    assert(!(Map_noKeyP(key)));

    /*
    * Make sure there is room for at least one entry
    */
    if (body == 0) {
    alloc(1);
    }

    if ((foundP = locate(key, index))) {
    return &(BODY(body)->data[index].value);
    } else {
    unsigned maxEntries = hashSize(BODY(body)->maxBits);
    unsigned nEntries = BODY(body)->nEntries;

    /*
    * Rehash table if necessary
    */
    unsigned minSize = roundSize(nEntries + 1);

    if (minSize > maxEntries) {
        LHashBody<KeyT,DataT> *oldBody = BODY(body);
        unsigned i;

        /*
        * Since LHash_maxEntriesLimit is a power of two minus 1
        * we need to check this only when the array is enlarged
        */
        assert(nEntries < LHash_maxEntriesLimit);

        alloc(minSize);
        BODY(body)->nEntries = nEntries;

        if (BODY(body)->maxBits < minHashBits) {
        /*
        * Just copy old entries to new storage, no reindexing
        * required.
        */
        memcpy(BODY(body)->data, oldBody->data,
            sizeof(oldBody->data[0]) * nEntries);
        } else {
        /*
        * Rehash
        */
        for (i = 0; i < maxEntries; i++) {
            KeyT key = oldBody->data[i].key;

            if (! Map_noKeyP(key)) {
            (void)locate(key, index);
            memcpy(&(BODY(body)->data[index]), &(oldBody->data[i]),
                            sizeof(oldBody->data[0]));
            }
        }
        }
        free(oldBody);

        /*
        * Entries have been moved, so have to re-locate key
        */
        (void)locate(key, index);
    }

    BODY(body)->data[index].key = Map_copyKey(key);

    /*
    * Initialize data to zero, but also call constructors, if any
    */
    memset(&(BODY(body)->data[index].value), 0,
            sizeof(BODY(body)->data[index].value));
    new (&(BODY(body)->data[index].value)) DataT;

    BODY(body)->nEntries++;

    return &(BODY(body)->data[index].value);
    }
}

template <class KeyT, class DataT>
DataT *
LHash<KeyT,DataT>::remove(KeyT key, Boolean &foundP)
{
    unsigned index;

    /*
    * Allocate pseudo-static memory for removed objects (returned by
    * remove()). We cannot make this static because otherwise
    * the destructor for DataT would be called on it at program exit.
    */
    if (removedData == 0) {
    removedData = (DataT *)malloc(sizeof(DataT));
    assert(removedData != 0);
    }

    if ((foundP = locate(key, index))) {
    Map_freeKey(BODY(body)->data[index].key);
    Map_noKey(BODY(body)->data[index].key);
    memcpy(removedData, &BODY(body)->data[index].value, sizeof(DataT));

    if (BODY(body)->maxBits < minHashBits) {
        /*
        * Linear search mode -- Just move all entries above the
        * the one removed to fill the gap.
        */
        unsigned nEntries = BODY(body)->nEntries;

        memmove(&BODY(body)->data[index],
            &BODY(body)->data[index+1],
            (nEntries - index - 1) * sizeof(BODY(body)->data[0]));
        Map_noKey(BODY(body)->data[nEntries - 1].key);
    } else {
        /*
        * The entry after the one being deleted could actually
        * belong to a prior spot in the table, but was bounced forward due
        * to a collision.  The invariant used in lookup is that
        * all locations between the hash index and the actual index are
        * filled.  Hence we examine all entries between the deleted
        * position and the next free position as whether they need to
        * be moved backward.
        */
        while (1) {
        unsigned newIndex;

        index = (index + 1) & hashMask(BODY(body)->maxBits);

        if (Map_noKeyP(BODY(body)->data[index].key)) {
            break;
        }

        /*
        * If find returns false that means the deletion has
        * introduced a hole in the table that would prevent
        * us from finding the next entry. Luckily, find
        * also tells us where the hole is.  We move the
        * entry to its rightful place and continue filling
        * the hole created by this move.
        */
        if (!locate(BODY(body)->data[index].key, newIndex)) {
            memcpy(&(BODY(body)->data[newIndex]),
              &(BODY(body)->data[index]),
              sizeof(BODY(body)->data[0]));
            Map_noKey(BODY(body)->data[index].key);
        }
        }
    }
    BODY(body)->nEntries--;
    return removedData;
    } else {
    return 0;
    }
}

#ifdef __GNUG__
static
#endif
int (*LHash_thisKeyCompare)();        /* used by LHa........er() to communicate
                    * with compareIndex() */
#ifdef __GNUG__
static
#endif
void *LHash_thisBody;            /* ditto */

template <class KeyT, class DataT>
void
LHa........er<KeyT,DataT>::sortKeys()
{
    /*
    * Store keys away and sort them to the user's orders.
    */
    unsigned maxEntries = hashSize(myLHashBody->maxBits);

    unsigned *sortedIndex = new unsigned[numEntries];
    assert(sortedIndex != 0);

    unsigned i;

    unsigned j = 0;
    for (i = 0; i < maxEntries; i++) {
    if (!Map_noKeyP(myLHashBody->data[i].key)) {
        sortedIndex[j++] = i;
    }
    }
    assert(j == numEntries);

    /*
    * Due to the limitations of the qsort interface we have to
    * pass extra information to compareIndex in these global
    * variables - yuck.
    */
    LHash_thisKeyCompare = (int(*)())sortFunction;
    LHash_thisBody = myLHashBody;
    qsort(sortedIndex, numEntries, sizeof(*sortedIndex), compareIndex);

    /*
    * Save the keys for enumeration.  The reason we save the keys,
    * not the indices, is that indices may change during enumeration
    * due to deletions.
    */
    sortedKeys = new KeyT[numEntries];
    assert(sortedKeys != 0);

    for (i = 0; i < numEntries; i++) {
    sortedKeys[i] = myLHashBody->data[sortedIndex[i]].key;
    }

    delete [] sortedIndex;
}

template <class KeyT, class DataT>
LHa........er<KeyT,DataT>::LHa........er(const LHash<KeyT,DataT> &lhash,
                    int (*keyCompare)(KeyT, KeyT))
    : myLHashBody(BODY(lhash.body)), current(0),
      numEntries(lhash.numEntries()), sortFunction(keyCompare)
{
    /*
    * Note: we access the underlying LHash through the body pointer,
    * not the top-level LHash itself.  This allows the top-level object
    * to be moved without affecting an ongoing iteration.
    * XXX: This only works because
    * - it is illegal to insert while iterating
    * - deletions don't cause reallocation of the data
    */
    if (sortFunction && myLHashBody) {
    sortKeys();
    } else {
    sortedKeys = 0;
    }
}

/*
 * This is the callback function passed to qsort for comparing array
 * entries. It is passed the indices into the data array, which are
 * compared according to the user-supplied function applied to the
 * keys found at those locations.
 */
template <class KeyT, class DataT>
int
LHa........er<KeyT,DataT>::compareIndex(const void *idx1, const void *idx2)
{
    return (*(compFnType)LHash_thisKeyCompare)
            (BODY(LHash_thisBody)->data[*(unsigned *)idx1].key,
            BODY(LHash_thisBody)->data[*(unsigned *)idx2].key);
}

template <class KeyT, class DataT>
LHa........er<KeyT,DataT>::~LHa........er()
{
    delete [] sortedKeys;
}


template <class KeyT, class DataT>
void
LHa........er<KeyT,DataT>::init()
{
    delete [] sortedKeys;

    current = 0;

    {
    /*
    * XXX: fake LHash object to access numEntries()
    */
    LHash<KeyT,DataT> myLHash(0);

    myLHash.body = myLHashBody;
    numEntries = myLHash.numEntries();
    myLHash.body = 0;
    }

    if (sortFunction && myLHashBody) {
    sortKeys();
    } else {
    sortedKeys = 0;
    }
}

template <class KeyT, class DataT>
DataT *
LHa........er<KeyT,DataT>::next(KeyT &key)
{

    if (myLHashBody == 0) {
    return 0;
    } else {
    unsigned index;

    if (sortedKeys) {
        /*
        * Sorted enumeration -- advance to next key in sorted list
        */
        if (current == numEntries) {
        return 0;
        }

        /*
        * XXX: fake LHash object to access locate()
        */
        LHash<KeyT,DataT> myLHash(0);

        myLHash.body = myLHashBody;
        myLHash.locate(sortedKeys[current++], index);
        myLHash.body = 0;;
    } else {
        /*
        * Detect deletions by comparing old and current number of
        * entries.
        * A legal deletion can only affect the current entry, so
        * adjust the current position to reflect the next entry was
        * moved.
        */
        if (myLHashBody->nEntries != numEntries) {
        assert(myLHashBody->nEntries == numEntries - 1);

        numEntries --;
        current --;
        }

        /*
        * Random enumeration mode
        */
        unsigned maxBits = myLHashBody->maxBits;

        if (maxBits < minHashBits) {
        /*
        * Linear search mode - advance one to the next entry
        */
        if (current == numEntries) {
            return 0;
        }
        } else {
        unsigned maxEntries = hashSize(maxBits);

        while (current < maxEntries &&
              Map_noKeyP(myLHashBody->data[current].key))
        {
            current++;
        }

        if (current == maxEntries) {
            return 0;
        }
        }

        index = current ++;
    }

    key = myLHashBody->data[index].key;
    return &(myLHashBody->data[index].value);
    }
}

#undef BODY

#endif /* _LHash_cc_ */

---

You're going to get these undefined references errors all the time UNTIL you put ALL the .o files on your list. If you are referencing something that appears in a different file, well then, it's not going to work if you decide to leave that file out. Here it's referencing a member variable of the class, so the compiler needs to make sure it has the definition of the class.

I don't get what you mean. would you explain more?

You said there are 18 .c files, each of which needs to be turned into an .o file. And yet:

Code:

---

OBJ_READMATRIX= LHash.o Map.o zio.o Array.o File.o Vocab.o option.o ngram-count.o

---

So where are the other 10 .o files?