How can I read Header file in VSCode in mac? - visual-studio-code

I have some errors in VSCode.
I think VSCode can't read header file, but not exactly.
Environment is mac, m1. I already installed C/C++, C/C++ Extension Pack.
Here is my main code
#include <stdio.h>
#include "ArrayList.h"
int main(void){
List list;
int data;
ListInit(&list);
LInsert(&list, 11); LInsert(&list, 11);
LInsert(&list, 22); LInsert(&list, 22);
LInsert(&list, 33);
printf("현재 데이터 수 ; %d \n", LCount(&list));
if(LFirst(&list, &data)){
printf("%d", data);
while(LNext(&list, &data))
printf("%d", data);
}
printf("\n\n");
if(LFirst(&list, &data)){
if(data == 22)
LRemove(&list);
while(LNext(&list, &data)){
if(data == 22)
LRemove(&list);
}
}
printf("현재 데이터의 수");
if(LFirst(&list, &data)){
printf("%d", data);
while(LNext(&list, &data))
printf("%d", data);
}
printf("\n\n");
return 0;
}
...And this is "ArrayList.h"
#ifndef __ARRAY_LIST_H__
#define __ARRAY_LIST_H__
#define TRUE 1
#define FALSE 0
#define LIST_LEN 100
typedef int LData;
typedef struct __ArrayList
{
LData arr[LIST_LEN];
int numOfData;
int curPosition;
} ArrayList;
typedef ArrayList List;
void ListInit(List * plist);
void LInsert(List * plist, LData data);
int LFirst(List * plist, LData * pdata);
int LNext(List * plist, LData * pdata);
LData LRemove(List * plist);
int LCount(List * plist);
#endif
..And this is "ArrayList.c"
#include <stdio.h>
#include "ArrayList.h"
void ListInit(List * plist)
{
(plist->numOfData) = 0;
(plist->curPosition) = -1;
}
void LInsert(List * plist, LData data)
{
if(plist->numOfData > LIST_LEN)
{
puts("Can't save data.");
return;
}
plist->arr[plist->numOfData] = data;
(plist->numOfData)++;
}
int LFirst(List * plist, LData * pdata)
{
if(plist->numOfData == 0)
return FALSE;
(plist->curPosition) = 0;
*pdata = plist->arr[0];
return TRUE;
}
int LNext(List * plist, LData * pdata)
{
if(plist->curPosition >= (plist->numOfData)-1)
return FALSE;
(plist->curPosition)++;
*pdata = plist->arr[plist->curPosition];
return TRUE;
}
LData LRemove(List * plist)
{
int rpos = plist->curPosition;
int num = plist->numOfData;
int i;
LData rdata = plist->arr[rpos];
for(i=rpos; i<num-1; i++)
plist->arr[i] = plist->arr[i+1];
(plist->numOfData)--;
(plist->curPosition)--;
return rdata;
}
int LCount(List * plist)
{
return plist->numOfData;
}
and here is my error.
cd "/Users/henry/C:c++/3장 연결리스트1/" && gcc ListMain.c -o ListMain && "/Users/henry/C:c++/3장 연결리스트
1/"ListMain
Undefined symbols for architecture arm64:
"_LCount", referenced from:
_main in ListMain-651a0c.o
"_LFirst", referenced from:
_main in ListMain-651a0c.o
"_LInsert", referenced from:
_main in ListMain-651a0c.o
"_LNext", referenced from:
_main in ListMain-651a0c.o
"_LRemove", referenced from:
_main in ListMain-651a0c.o
"_ListInit", referenced from:
_main in ListMain-651a0c.o
ld: symbol(s) not found for architecture arm64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
All codes are in same folder. What's my problem?

Related

ioctl in kernel module: why some commands are not executed?

I attach here my kernel module I developed and the test I am using at application level
memalloc.c
/*
* DMA memory allocation
* This kernel module allocates coherent, non-cached memory
* and returns the physical and virtual address of the allocated buffer
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include "memalloc.h"
#define DEVICE_NAME "memalloc"
// Max number of buffers
#define BUFFER_MAX_NUMBER 16
// Structure for buffer information
struct bufferInfo {
int active;
int size;
dma_addr_t handle;
int virtualAddress;
int *kernelAddress;
};
static struct bufferInfo bufferInfoTable[BUFFER_MAX_NUMBER];
// Defines which buffer is currently active - for mmap
static int activeBufferID;
struct memAllocIF {
struct device *device_p;
dev_t dev_node;
struct cdev cdev;
struct class *class_p;
};
static struct memAllocIF interface;
// Methods
static int releaseBuffer(int i)
{
if (i > BUFFER_MAX_NUMBER)
{
printk("Wrong bufferID %d\n", i);
return -1;
}
printk("Releasing buffer %d\n", i);
bufferInfoTable[i].active = 0;
dma_free_coherent(NULL, bufferInfoTable[i].size, bufferInfoTable[i].kernelAddress, bufferInfoTable[i].handle);
return 0;
}
static int reserveBuffer(size_t size)
{
int i;
for (i = 0; i < BUFFER_MAX_NUMBER; i++)
{
if (bufferInfoTable[i].active == 0)
{
printk("Reserving buffer %d\n", i);
bufferInfoTable[i].active = 1;
break;
}
}
if (i < BUFFER_MAX_NUMBER)
{
bufferInfoTable[i].kernelAddress = dma_alloc_coherent(NULL, size, &bufferInfoTable[i].handle, GFP_KERNEL);
if (bufferInfoTable[i].kernelAddress == NULL)
{
printk("Allocation failure\n");
return -1;
}
bufferInfoTable[i].size = (int)size;
return i;
}
else
{
printk("No buffer available\n");
return -1;
}
}
static void cleanup(void)
{
int i;
for (i = 0; i < BUFFER_MAX_NUMBER; i++)
{
if (bufferInfoTable[i].active != 0)
{
dma_free_coherent(NULL, bufferInfoTable[i].size, bufferInfoTable[i].kernelAddress, bufferInfoTable[i].handle);
bufferInfoTable[i].active = 0;
}
}
}
static unsigned int memAllocGetVirtual (int i)
{
if (i > BUFFER_MAX_NUMBER)
{
printk("Wrong bufferID %d\n", i);
return -1;
}
if (bufferInfoTable[i].active == 0)
{
printk("Inactive buffer - ID %d\n", i);
return -1;
}
printk("request for buffer %d: vaddr = %X\n", i, (unsigned int)bufferInfoTable[i].virtualAddress);
return bufferInfoTable[i].virtualAddress;
}
static unsigned int memAllocGetPhysical (int i)
{
if (i > BUFFER_MAX_NUMBER)
{
printk("Wrong bufferID %d\n", i);
return -1;
}
return (unsigned int)bufferInfoTable[i].handle;
}
static long memAllocIoctl (struct file *fd, unsigned int cmd, unsigned long arg)
{
printk("received command %u arg %lu\n", cmd, arg);
switch(cmd)
{
case MEMALLOC_RESERVE:
return reserveBuffer(arg);
break;
case MEMALLOC_RELEASE:
return releaseBuffer(arg);
break;
case MEMALLOC_GET_VIRTUAL:
return memAllocGetVirtual(arg);
break;
case MEMALLOC_GET_PHYSICAL:
return memAllocGetPhysical(arg);
break;
case MEMALLOC_ACTIVATE_BUFFER:
if (arg > BUFFER_MAX_NUMBER || bufferInfoTable[arg].active == 0)
{
printk("Wrong bufferID %lu\n", arg);
return -1;
}
activeBufferID = arg;
return arg;
break;
default:
printk("Wrong command: %d\n", cmd);
return -1;
break;
}
}
static int memAllocMmap (struct file *fd, struct vm_area_struct *vma)
{
bufferInfoTable[activeBufferID].virtualAddress = dma_common_mmap(interface.device_p, vma, bufferInfoTable[activeBufferID].kernelAddress, bufferInfoTable[activeBufferID].handle, vma->vm_end-vma->vm_start);
printk("mmap for idx %d: vaddr = %X\n", activeBufferID, (int)bufferInfoTable[activeBufferID].virtualAddress);
return bufferInfoTable[activeBufferID].virtualAddress;
}
static int memAllocRelease(struct inode *in, struct file *fd)
{
cleanup();
return 0;
}
static int memAllocOpen(struct inode *ino, struct file *file)
{
file->private_data = container_of(ino->i_cdev, struct memAllocIF, cdev);
return 0;
}
static struct file_operations fops = {
.unlocked_ioctl = memAllocIoctl,
.mmap = memAllocMmap,
.release = memAllocRelease,
.open = memAllocOpen
};
static int __init memAllocInit(void)
{
int rc;
int i;
static struct class *local_class_p = NULL;
printk("Loading DMA allocation module\n");
// Allocate a character device from the kernel for this driver
rc = alloc_chrdev_region(&interface.dev_node, 0, 1, DEVICE_NAME);
if (rc)
{
printk("Unable to get a char device number\n");
return rc;
}
// Initialize the ter device data structure before registering the character device with the kernel
cdev_init(&interface.cdev, &fops);
rc = cdev_add(&interface.cdev, interface.dev_node, 1);
if (rc)
{
printk("Unable to add char device\n");
cdev_del(&interface.cdev);
return rc;
}
// Create the device in sysfs which will allow the device node in /dev to be created
local_class_p = class_create(THIS_MODULE, DEVICE_NAME);
interface.class_p = local_class_p;
// Create the device node in /dev so the device is accessible as a character device
interface.device_p = device_create(interface.class_p, NULL, interface.dev_node, NULL, DEVICE_NAME);
if (IS_ERR(interface.device_p))
{
printk("Unable to create the device\n");
class_destroy(interface.class_p);
cdev_del(&interface.cdev);
return rc;
}
for (i = 0; i < BUFFER_MAX_NUMBER; i++)
{
bufferInfoTable[activeBufferID].active = 0;
}
return 0;
}
static void __exit my_memAllocExit(void)
{
printk("Module unloading\n");
cleanup();
cdev_del(&interface.cdev);
device_destroy(interface.class_p, interface.dev_node);
class_destroy(interface.class_p);
unregister_chrdev_region(interface.dev_node, 1);
}
module_init(memAllocInit);
module_exit(my_memAllocExit);
MODULE_AUTHOR("me");
MODULE_DESCRIPTION("Create a buffer and return physical and virtual address, for DMA userspace driver");
MODULE_LICENSE("GPL");
memalloc.h
#ifndef MEMALLOC_H
#define MEMALLOC_H
#ifdef __cplusplus
extern "C" {
#endif
#include <linux/types.h>
#include <asm/ioctl.h>
static long memAllocIoctl (struct file *, unsigned int, unsigned long);
static int memAllocMmap (struct file *, struct vm_area_struct *);
static int memAllocRelease (struct inode *, struct file *);
static int memAllocOpen(struct inode *, struct file *);
enum memAllocCmd
{
MEMALLOC_RESERVE = 0,
MEMALLOC_RELEASE = 1,
MEMALLOC_GET_VIRTUAL = 2,
MEMALLOC_GET_PHYSICAL = 3,
MEMALLOC_ACTIVATE_BUFFER = 4,
};
#ifdef __cplusplus
}
#endif
#endif /* MEMALLOC_H */
test.c
#include <stdlib.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdio.h>
// derive this from memalloc.h
enum memAllocCmd
{
MEMALLOC_RESERVE = 0,
MEMALLOC_RELEASE = 1,
MEMALLOC_GET_VIRTUAL = 2,
MEMALLOC_GET_PHYSICAL = 3,
MEMALLOC_ACTIVATE_BUFFER = 4,
};
int main ()
{
int memAllocFd;
volatile int iVaddr;
volatile int oVaddr;
volatile int iVaddr_2;
volatile int oVaddr_2;
volatile void * iPaddr;
volatile void * oPaddr;
int iBufID;
int oBufID;
int size = 2048;
memAllocFd = open("/dev/memalloc", O_RDWR);
// create iBuffer
iBufID = ioctl(memAllocFd, MEMALLOC_RESERVE, size);
iPaddr = (void *)ioctl(memAllocFd, MEMALLOC_GET_PHYSICAL, iBufID);
ioctl(memAllocFd, MEMALLOC_ACTIVATE_BUFFER, iBufID);
iVaddr = (int)mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, memAllocFd, 0);
ioctl(memAllocFd, MEMALLOC_GET_VIRTUAL, iBufID);
/*
if (iVaddr != iVaddr_2)
{
printf("Error: virtual addresses for buffer %d don't match: %X %X\n", iBufID, iVaddr, iVaddr_2);
}
*/
// create oBuffer
oBufID = ioctl(memAllocFd, MEMALLOC_RESERVE, size);
oPaddr = (void *)ioctl(memAllocFd, MEMALLOC_GET_PHYSICAL, oBufID);
ioctl(memAllocFd, MEMALLOC_ACTIVATE_BUFFER, oBufID);
oVaddr = (int)mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, memAllocFd, 0);
ioctl(memAllocFd, MEMALLOC_GET_VIRTUAL, oBufID);
/*
if (oVaddr != oVaddr_2)
{
printf("Error: virtual addresses for buffer %d don't match: %X %X\n", oBufID, oVaddr, oVaddr_2);
}
*/
ioctl(memAllocFd, MEMALLOC_RELEASE, iBufID);
ioctl(memAllocFd, MEMALLOC_RELEASE, oBufID);
return 0;
}
Result of the test is
received command 0 arg 2048
Reserving buffer 0
received command 3 arg 0
received command 4 arg 0
mmap for idx 0: vaddr = 0
received command 0 arg 2048
Reserving buffer 1
received command 3 arg 1
received command 4 arg 1
mmap for idx 1: vaddr = 0
received command 1 arg 0
Releasing buffer 0
received command 1 arg 1
Releasing buffer 1
Which means that all ioctl calls with arg=MEMALLOC_GET_VIRTUAL are not executed, while all the others are.
What can be the reason for that?
Thanks,
Max

How can I compile HAL examples on Neatbeans?

I am trying to compile a HAL API example on Netbeans. Netbeans shows warning and error about some header files. But I am able to compile my sample codes using following command line:
gcc `pkg-config --libs --cflags dbus-1 hal hal-storage dbus-glib-1 glib-2.0` main.c HalDemos.c HalDemos.h -o HalDemos -lpthread
How can apply this command to my Netbeans project?
Here the codes which I am trying to compile:
/*
* File: HallDemos.h
* Author: olcay
*
* Created on December 25, 2011, 5:05 AM
*/
#ifndef HALLDEMOS_H
#define HALLDEMOS_H
#ifdef __cplusplus
extern "C" {
#endif
#include <hal/libhal.h>
#include <hal/libhal-storage.h>
#include <dbus/dbus.h>
#include <glib-1.2/glib.h>
//#include <dbus/dbus-glib-lowlevel.h>
#define HAL_DBUS_SERVICE "org.freedesktop.Hal"
#define HAL_ROOT_COMPUTER "/org/freedesktop/Hal/devices/computer"
#define HAL_DBUS_INTERFACE_POWER "org.freedesktop.Hal.Device.SystemPowerManagement"
static void handle_device_removed(LibHalContext *ctx, const char *udi);
static void handle_device_added(LibHalContext *ctx, const char *udi);
DBusConnection *connection;
DBusError error;
DBusMessage *mess;
DBusMessage *reply;
LibHalContext *ctx;
LibHalDrive *drive;
LibHalVolume *volume;
const char *udi;
int exit_code;
int initHal();
int getSystemInfo();
int getDeviceWithCapability(const char *capability);
void callbackLoop();
void listDeviceContent();
#ifdef __cplusplus
}
#endif
#endif /* HALLDEMOS_H */
#include "HalDemos.h"
#include <stdio.h>
static void handle_device_removed(LibHalContext *ctx, const char *udi) {
printf("Device with udi=%s is removed\n", udi);
}
static void handle_device_added(LibHalContext *ctx, const char *udi) {
dbus_bool_t is_storage;
is_storage = libhal_device_query_capability(ctx, udi, "storage", NULL);
if (is_storage) {
drive = libhal_drive_from_udi(ctx, udi);
volume = libhal_volume_from_udi(ctx, udi);
if (libhal_drive_is_hotpluggable(drive) || libhal_drive_uses_removable_media(drive)) {
printf("Storage device added %s model %s\n",
libhal_drive_get_device_file(drive),
libhal_drive_get_model(drive));
//printf("Mount point = %s\n", libhal_volume_get_mount_point(volume));
}
libhal_drive_free(drive);
}
//printf("Device with udi=%s is added\n", udi);
}
int initHal() {
udi = "/org/freedesktop/Hal/devices/computer";
dbus_error_init(&error);
connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (dbus_error_is_set(&error)) {
printf("Unable to connect to Dbus: %s\n", error.message);
dbus_error_free(&error);
return 1;
}
ctx = libhal_ctx_new();
if (!libhal_ctx_set_dbus_connection(ctx, connection)) {
printf("Error: %s\n", error.message);
dbus_error_free(&error);
return 1;
}
if (!libhal_ctx_init(ctx, &error)) {
printf("Hal context initializing failure %s\n", error.message);
return 1;
}
}
int getSystemInfo() {
char *kernel_version = libhal_device_get_property_string(ctx, udi, "system.kernel.version", &error);
if (dbus_error_is_set(&error)) {
printf("Error getting string property %s\n", error.message);
dbus_error_free(&error);
return 1;
}
char *power_management_type = libhal_device_get_property_string(ctx, udi, "power_management.type", &error);
if (dbus_error_is_set(&error)) {
printf("Error getting string property %s\n", error.message);
dbus_error_free(&error);
return 1;
}
dbus_bool_t can_hibernate = libhal_device_get_property_bool(ctx, udi, "power_management.can_hibernate", &error);
if (dbus_error_is_set(&error)) {
printf("Error getting bool property %s\n", error.message);
dbus_error_free(&error);
return 1;
}
printf("System information:\n");
printf("Kernel = %s\n", kernel_version);
printf("Power management type = %s\n", power_management_type);
printf("Hibernate = %s\n", can_hibernate ? "Supported" : "Not supported");
libhal_free_string(kernel_version);
libhal_free_string(power_management_type);
return 0;
}
int getDeviceWithCapability(const char* capability) {
int num_devices = 0;
char **udis = libhal_find_device_by_capability(ctx, capability, &num_devices, &error);
if (dbus_error_is_set(&error)) {
printf("Error getting bool property %s\n", error.message);
dbus_error_free(&error);
return 1;
}
if (num_devices == 0) {
printf("No device found with input capability!");
return 0;
}
int i;
printf("Devices with input capability:\n");
for (i = 0; udis[i]; i++) {
printf("%2d - udi = %s\n", i + 1, udis[i]);
/* Do something with it */
}
/* Free the string array */
libhal_free_string_array(udis);
}
void callbackLoop() {
GMainLoop *loop;
loop = (GMainLoop*) g_main_loop_new(NULL, FALSE);
dbus_connection_setup_with_g_main(connection, NULL);
libhal_ctx_set_device_added(ctx, handle_device_added);
libhal_ctx_set_device_removed(ctx, handle_device_removed);
g_main_loop_run(loop);
}
void listDeviceContent(){
}
UPDATE:
Writing the command I used with $$() and adding it to additional compiler settings solved my problem.
Go to your project properties -> Build -> C Compiler -> Additional Options
Put your compiler flags here between $$() like:
$$(pkg-config --libs --cflags dbus-1 hal hal-storage dbus-glib-1 glib-2.0)

Are there simple examples of how to parse a simple JSON file using the C-based YAJL library?

I know there is an Objective-C wrapper around YAJL, but this is a really fat thing which blows up the whole JASON parser to a ridiculous huge amount of 21 files, many of them with tiny scroll bars.
So to keep my app binary small I'd like to stick with the C-version of that parser. But I'm having a hard time finding any useful documentation for this rather than the wrapper.
Maybe someone who used the C-base can point out such a tutorial or documentation?
The documentation with C examples can be found here: http://lloyd.github.com/yajl/
The github repository with examples can be found here : https://github.com/lloyd/yajl
Here is a C example that reformats JSON from stdin:
#include <yajl/yajl_parse.h>
#include <yajl/yajl_gen.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
static int reformat_null(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_null(g);
}
static int reformat_boolean(void * ctx, int boolean)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_bool(g, boolean);
}
static int reformat_number(void * ctx, const char * s, size_t l)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_number(g, s, l);
}
static int reformat_string(void * ctx, const unsigned char * stringVal,
size_t stringLen)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_string(g, stringVal, stringLen);
}
static int reformat_map_key(void * ctx, const unsigned char * stringVal,
size_t stringLen)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_string(g, stringVal, stringLen);
}
static int reformat_start_map(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_map_open(g);
}
static int reformat_end_map(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_map_close(g);
}
static int reformat_start_array(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_array_open(g);
}
static int reformat_end_array(void * ctx)
{
yajl_gen g = (yajl_gen) ctx;
return yajl_gen_status_ok == yajl_gen_array_close(g);
}
static yajl_callbacks callbacks = {
reformat_null,
reformat_boolean,
NULL,
NULL,
reformat_number,
reformat_string,
reformat_start_map,
reformat_map_key,
reformat_end_map,
reformat_start_array,
reformat_end_array
};
static void
usage(const char * progname)
{
fprintf(stderr, "%s: reformat json from stdin\n"
"usage: json_reformat [options]\n"
" -m minimize json rather than beautify (default)\n"
" -u allow invalid UTF8 inside strings during parsing\n",
progname);
exit(1);
}
int
main(int argc, char ** argv)
{
yajl_handle hand;
static unsigned char fileData[65536];
/* generator config */
yajl_gen g;
yajl_status stat;
size_t rd;
int retval = 0;
int a = 1;
g = yajl_gen_alloc(NULL);
yajl_gen_config(g, yajl_gen_beautify, 1);
yajl_gen_config(g, yajl_gen_validate_utf8, 1);
/* ok. open file. let's read and parse */
hand = yajl_alloc(&callbacks, NULL, (void *) g);
/* and let's allow comments by default */
yajl_config(hand, yajl_allow_comments, 1);
/* check arguments.*/
while ((a < argc) && (argv[a][0] == '-') && (strlen(argv[a]) > 1)) {
unsigned int i;
for ( i=1; i < strlen(argv[a]); i++) {
switch (argv[a][i]) {
case 'm':
yajl_gen_config(g, yajl_gen_beautify, 0);
break;
case 'u':
yajl_config(hand, yajl_dont_validate_strings, 1);
break;
default:
fprintf(stderr, "unrecognized option: '%c'\n\n",
argv[a][i]);
usage(argv[0]);
}
}
++a;
}
if (a < argc) {
usage(argv[0]);
}
for (;;) {
rd = fread((void *) fileData, 1, sizeof(fileData) - 1, stdin);
if (rd == 0) {
if (!feof(stdin)) {
fprintf(stderr, "error on file read.\n");
retval = 1;
}
break;
}
fileData[rd] = 0;
stat = yajl_parse(hand, fileData, rd);
if (stat != yajl_status_ok) break;
{
const unsigned char * buf;
size_t len;
yajl_gen_get_buf(g, &buf, &len);
fwrite(buf, 1, len, stdout);
yajl_gen_clear(g);
}
}
stat = yajl_complete_parse(hand);
if (stat != yajl_status_ok) {
unsigned char * str = yajl_get_error(hand, 1, fileData, rd);
fprintf(stderr, "%s", (const char *) str);
yajl_free_error(hand, str);
retval = 1;
}
yajl_gen_free(g);
yajl_free(hand);
return retval;
}

class has no member problem (code works find in VS, but failed in Ubuntu)

all
I got a piece of code about sparse matrix, it works fine in VISUAL STUDIO 2008, but when I want to port it to ubuntu environment, the compiler report the following errors:
../include/spmatrix.h(123): error:
class template "numc::CSRMatrix"
has no member "resize"
../include/spmatrix.h(170): error:
expected a ";"
../include/spmatrix.h(171): error:
identifier "it" is undefined
../include/spmatrix.h(176): error:
expected a ";"
../include/spmatrix.h(178): error:
identifier "it" is undefined
../include/spmatrix.h(183): error:
identifier "size" is undefined
../include/spmatrix.h(185): error:
expected a ";"
../include/spmatrix.h(185): error:
identifier "it" is undefined
.> ./include/spmatrix.h(186): error:
expected a ";"
../include/spmatrix.h(187): error:
identifier "cit" is undefined
../include/spmatrix.h(205): error:
expected a ";"
../include/spmatrix.h(205): error:
identifier "it" is undefined
../include/spmatrix.h(218): error:
expected a ";"
../include/spmatrix.h(218): error:
identifier "it" is undefined
../include/spmatrix.h(222): error:
expected a ";"
../include/spmatrix.h(223): error:
identifier "f" is undefined
../include/spmatrix.h(224): error:
identifier "make_pair" is undefined
../include/spmatrix.h(224): error:
type name is not allowed
../include/spmatrix.h(224): error:
type name is not allowed
../include/spmatrix.h(245): error:
identifier "RowType" is undefined
../include/spmatrix.h(246): error:
name followed by "::" must be a class
or namespace name
../include/spmatrix.h(246): error:
expected a ";"
../include/spmatrix.h(246): error:
identifier "it" is undefined
../include/spmatrix.h(269): error:
identifier "RowType" is undefined
../include/spmatrix.h(270): error:
name followed by "::" must be a class
or namespace name
../include/spmatrix.h(270): error:
expected a ";"
../include/spmatrix.h(271): error:
identifier "it" is undefined
../include/spmatrix.h(276): error:
identifier "RowType" is undefined
../include/spmatrix.h(276): error:
identifier "crow" is undefined
../include/spmatrix.h(277): error:
name followed by "::" must be a class
or namespace name
../include/spmatrix.h(277): error:
expected a ";"
../include/spmatrix.h(279): error:
identifier "it" is undefined
../include/spmatrix.h(311): error:
expected a ";"
../include/spmatrix.h(311): error:
identifier "it" is undefined
../include/spmatrix.h(350): error:
expected a ";"
../include/spmatrix.h(350): error:
identifier "it" is undefined
../include/spmatrix.h(423): error:
expected a ";"
../include/spmatrix.h(424): error:
identifier "it" is undefined
../include/spmatrix.h(484): error:
expected a ";"
../include/spmatrix.h(485): error:
identifier "it" is undefined
../include/spmatrix.h(518): error:
expected a ";"
../include/spmatrix.h(520): error:
identifier "it" is undefined
I try to figure out where the problem is, but failed. Hope you can give me some hint where the problem is. Thanks in advance for your help!
Below is the code of this sparse matrix, it is just a header file:
#pragma warning(disable: 4786)
#ifndef NUMC_CSRMATRIX_H
#define NUMC_CSRMATRIX_H
#include <cmath>
#include <map>
#include <vector>
#include <limits>
#include <algorithm>
#ifndef _NUMC_BEGIN
#define _NUMC_BEGIN namespace numc {
#define _NUMC_END }
#endif
_NUMC_BEGIN
using std::vector;
using std::map;
using std::swap;
using std::lower_bound;
template<typename R> class CSRMatrix;
template<typename R> struct RowMat;
template<typename R> void CreateCSRMatrixFromRowMap(CSRMatrix<R>&, const RowMat<R>&);
t emplate<typename R> void CSRMatrixTranspose (const CSRMatrix<R>&, CSRMatrix<R>&);
template<typename R> bool Mul2MatricesSymmResult (const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
template<typename R> bool Mul2MatricesSymmResult (const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
template<typename R> bool Mul2Matrices (const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
template<typename R> bool Mul2Matrices (const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
template<typename R>
class CSRMatrix
{
public:
enum MatType{ RealStrucSymm=1, RealSymmPosDef=2, RealSymmIndef=-2,
CompStrucSymm=3, CompHermPosDef=4, CompHermIndef=-4,
CompSymm=6, RealUnSymm=11, CompUnSymm=13};
std::vector<R> mAv;
std::vector<int> mAi, mAj;
CSRMatrix():mNRow(0),mNCol(0),mMtype(RealUnSymm) {};
CSRMatrix(const RowMat<R> &rm):mMtype(RealUnSymm) { CreateCSRMatrixFromRowMap(*this, rm); }
MatType mMtype;
#if ( defined(_MSC_VER)&&(_MSC_VER>1300) )
//template<typename T> class CSRMatrix;
#define FFM <> // FFM FRIEND_FUNCTION_MAGIC
#else
#define FFM
#endif
friend void CreateCSRMatrixFromRowMap FFM(CSRMatrix<R>&, const RowMat<R>&);
friend void CSRMatrixTranspose FFM(const CSRMatrix<R>&, CSRMatrix<R>&);
friend bool Mul2MatricesSymmResult FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
friend bool Mul2MatricesSymmResult FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
friend bool Mul2Matrices FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, RowMat<R>&);
friend bool Mul2Matrices FFM(const CSRMatrix<R>&, const CSRMatrix<R>&, CSRMatrix<R>&);
#undef FFM
private:
int mNRow, mNCol;
public:
inline int nRow() const { return mNRow; }
inline int nCol() const { return mNCol; }
inline int empty() const { return (0==nRow() || 0==nCol()) ;}
inline bool onebase() const { return (!mAi.empty()) && (mAi[0]==1); } //default: zerobase, including empty matrix!
inline MatType mtype() const { return mMtype; }
inline bool issymm() const
{ return (RealSymmIndef==mMtype || RealSymmPosDef==mMtype || CompSymm==mMtype); }
inline void clear()
{ mNRow = 0; mNCol = 0; mMtype = RealUnSymm; mAv.clear(); mAi.clear(); mAj.clear(); }
R getElementV(int x, int y) const{
double *p = const_cast<CSRMatrix*>(this)->getElementP(x, y);
return (NULL==p)?0:*p;
}
R* getElementP(int x, int y) {
if (x<0||y<0) return NULL;
if ( issymm() && x>y) swap(x, y);
const int off = onebase();
std::vector<int>::const_iterator it = lower_bound(mAj.begin()+mAi[x]-off, mAj.begin()+(mAi[x+1]-off), y+off);
if (it==mAj.begin()+(mAi[x+1]-off) || *it!=(y+off) ) return NULL;
return &mAv.front() + ( it-mAj.begin() );
}
void MultiVect(R* in, R *out) const;
bool ChangeBase(bool oneBase) {
if( onebase() == oneBase ) return true;
int ii;
if (oneBase) {
if (mAi[0] != 0){
fprintf(stderr, "error matrix!");
return false;
}
for (ii=0; ii<mAi.back(); ii++) mAj[ii]++;
for (ii=0; ii<mNRow+1; ii++) mAi[ii]++;
}
else {
if (mAi[0] != 1){
fprintf(stderr, "error matrix!");
return false;
}
for (ii=0; ii<mAi.back()-1; ii++) mAj[ii]--;
for (ii=0; ii<mNRow+1; ii++) mAi[ii]--;
}
return true;
}
void GetSubMat(const std::vector<int> &xi, const std::vector<int> &yi, CSRMatrix& mat){
mat.resize( yi.size() );
for(int j=0; j<yi.size(); j++){
for(int i=0; i<xi.size(); i++){
}
}
}
void print(FILE *f=stdout){
fprintf(f, "The matrix:\n");
for(int i=0; i<nRow(); i++){
fprintf(f, "%2d#:", i);
for(int j=0; j<nCol(); j++) {
fprintf(f, "\t%.3e", getElementV(i, j) );
}
fprintf(f, "\n");
}
}
};
template<typename R>
struct RowMat:public vector<map<int, R> >
{
typedef map<int, R> RowType;
typedef vector<RowType> BaseType;
int mNCol;
RowMat(int nrow=0, int ncol=0):BaseType(nrow),mNCol(ncol) { }
~RowMat() { }
RowMat(const CSRMatrix<R> &mat)
{
resize(mat.nCol(), mat.nRow());
int off = mat.onebase()?1:0;
for(unsigned int i=0; i+1<mat.mAi.size(); i++){
for(int j=mat.mAi[i]; j<mat.mAi[i+1]; j++){
(*this)(i, mat.mAj[j-off]-off) = mat.mAv[ j-off ];
}
}
}
virtual bool symmetric() const {return false;}
virtual inline R operator()(int i, int j) const{
const RowType &crow = (*this)[i];
RowType::const_iterator it = crow.find(j);
return ( it==crow.end() )?0:it->second;
}
virtual inline R& operator()(int i, int j){
RowType &crow = (*this)[i];
RowType::iterator it = crow.find(j);
return ( it==crow.end() )?crow.insert( std::pair<int,R>(j, 0) ).first->second:it->second;
}
int clearZero() {
int nZero;
for (size_t i=0; i<size(); i++) {
RowType &r = (*this)[i];
for (RowType::const_iterator it=r.begin(); it!=r.end(); ) {
RowType::const_iterator cit = it++;
if(fabs(cit->second) < std::numeric_limits<R>::epsilon()){
r.erase(cit);
++nZero;
}
}
}
return nZero;
}
inline void resize(int nrow, int ncol=0) { BaseType::resize(nrow); mNCol = ncol>0?ncol:mNCol; }
inline int nRow() const { return BaseType::size(); }
inline int nCol() const { return mNCol; }
int operator+=(const RowMat<R>& r) { return add(r, 1); }
void operator *= (const double v) {
for(int i=0; i<nRow(); i++){
map<int, R>& crow = (*this)[i];
for(map<int,R>::iterator it=crow.begin(); it!=crow.end(); ++it){
it->second *= v;
}
}
}
int add(const RowMat<R>& r, R k){
const int h = nRow();
if( r.nRow() != h ) return -1;
for(int i=0; i<h; i++){
const map<int, R>& rrow = r[i];
map<int, R>& lrow = (*this)[i];
for(RowType::const_iterator it=rrow.begin(); it!=rrow.end(); ++it){
int col = it->first;
R val = it->second * k;
map<int,R>::iterator f = lrow.find(col);
if( f != lrow.end() ) f->second += val;
lrow.insert( make_pair<int, R>(col, val) );
}
}
return 0;
}
};
template<typename R>
struct RowMatSym : public RowMat<R>
{
typedef RowMat<R> Base;
RowMatSym(int nrow=0, int ncol=0):Base(nrow, ncol) {}
~RowMatSym() { }
RowMatSym(const RowMat<R> &rm){
resize(rm.nCol(), rm.nRow());
for(unsigned int i=0; i<rm.nRow(); i++){
const RowType &crow = rm[i];
for(RowType::const_iterator it=crow.begin(); it!=crow.end(); ++it){
(*this)(i, it->first) = it->second;
}
}
}
RowMatSym(const CSRMatrix<R> &mat)
{
resize(mat.nCol(), mat.nRow());
int off = mat.onebase()?1:0;
for(unsigned int i=0; i+1<mat.mAi.size(); i++){
for(int j=mat.mAi[i]; j<mat.mAi[i+1]; j++){
const int k = mat.mAj[j-off]-off;
(*this)(i, k) = mat.mAv[ j-off ];
}
}
}
virtual bool symmetric() const {return true;}
inline R operator()(int i, int j) const{
if(i>j) std::swap(i, j);
const RowType &crow = (*this)[i];
RowType::const_iterator it = crow.find(j);
return ( it==crow.end() )?0:it->second;
}
inline R& operator()(int i, int j){
if(i>j) std::swap(i, j);
RowType &crow = (*this)[i];
RowType::iterator it = crow.find(j);
return ( it==crow.end() )?crow.insert( std::pair<int,R>(j, 0) ).first->second
:it->second;
}
};
//////////////////////////////////////////////////////////////////////////
/// Get SubMatrix from rowmap
//////////////////////////////////////////////////////////////////////////
template <typename R>
void GetSubRowMap(const RowMat<R>& src,
const std::vector<int> &xi, const std::vector<int> &yi,
RowMat<R>& dst)
{
assert( xi.size()>0 && yi.size()>0 );
assert( yi.back() < (int)src.size() );
if( xi.empty() || yi.empty() || yi.back() >= (int)src.size() ){
fprintf(stderr, "\nerror matrix!");
return;
}
typedef std::map<int, R> row;
dst.resize( yi.size() );
for(unsigned int j=0; j<yi.size(); j++){
const row &srow = src[ yi[j] ];
row &drow = dst[j];
const int* pxi = &xi.front();
for(row::const_iterator it=srow.begin(); it!=srow.end(); ++it ){
pxi = std::lower_bound(pxi, &xi.back(), it->first);
if(*pxi != it->first){ // done
continue;
}
int col = pxi - &xi.front();
drow[col] = it->second;
}
}
}
//////////////////////////////////////////////////////////////////////////
/// Create CSR matrix from vector of rowmap
//////////////////////////////////////////////////////////////////////////
template <typename R>
void CreateCSRMatrixFromRowMap(CSRMatrix<R> &matC, const RowMat<R>& rowC)
{
if(rowC.mNCol <= 0){
fprintf(stderr, "\nnumber of column not specified in the RowMat, exit!");
return;
}
matC.clear();
matC.mNRow = rowC.nRow();
matC.mNCol = rowC.nCol();
matC.mAi.reserve(matC.nRow()+1);
int i,nnz=0;
for (i=0; i<matC.nRow(); i++) {
nnz += rowC[i].size();
}
matC.mAj.reserve(nnz);
matC.mAv.reserve(nnz);
// copy rows into matC
matC.mAi.push_back(0);
for (i=0; i<matC.nRow(); i++) {
matC.mAi.push_back(matC.mAi.back());
for (std::map<int, R>::const_iterator it=rowC[i].begin(); it!=rowC[i].end(); it++) {
matC.mAi.back()++;
matC.mAj.push_back(it->first);
matC.mAv.push_back(it->second);
}
}
}
//////////////////////////////////////////////////////////////////////////
/// Computes the transpose of a matrix.
template <typename R>
void CSRMatrixTranspose(const CSRMatrix<R> &matA, CSRMatrix<R> &matAT)
{
if (matA.issymm()) { // symmetric - just copy the matrix
matAT = matA;
return;
}
matAT.mNRow = matA.nCol();
matAT.mNCol = matA.nRow();
matAT.mMtype = matA.mMtype;
// non-symmetric matrix -> need to build data structure.
// we'll go over the columns and build the rows
int off = matA.onebase()?1:0;
RowMat<R> rowC(matA.nCol(), matA.nRow());
for (int i=0; i<matA.nRow(); i++) {
for (int j=matA.mAi[i]; j<matA.mAi[i+1]; j++) {
rowC[matA.mAj[j-off]-off][i] = matA.mAv[j-off];
}
}
CreateCSRMatrixFromRowMap(matAT, rowC);
}
//////////////////////////////////////////////////////////////////////////
// multiplication of sparse matrix
// Assuming nothing about the result (the result is not stored symmetric)
//////////////////////////////////////////////////////////////////////////
template <typename R>
bool Mul2Matrices(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB,
RowMat<R> &rowsC)
{
if(matA.onebase() || matB.onebase() ){
fprintf(stderr, "\nmatrix saved in 1-based format, pleased converted it to 0-based and try again!");
return false;
}
// Compatibility of dimensions
if (matA.nCol() != matB.nRow())
return false;
// (m x n)*(n x k) = (m x k)
const int m=matA.nRow();
const int n=matA.nCol();
const int k=matB.nCol();
rowsC = RowMat<R>(m, k); // clean all coefficients
R aiv, valB;
int colInd, colB;
for (int i=0; i<m; ++i) { // creating row i of C
std::map<int, R> &mapRow2Val = rowsC[i];
for (int iAi = matA.mAi[i]; iAi < matA.mAi[i+1]; ++iAi) { // travel on ai
colInd = matA.mAj[iAi];
aiv = matA.mAv[iAi];
// make aiv*b_{rowInd} and insert into mapRow2Val
for (int iB=matB.mAi[colInd]; iB<matB.mAi[colInd+1]; ++iB) {
colB=matB.mAj[iB];
valB=matB.mAv[iB];
// insert valA*aiv into map
std::map<int, R>::iterator it = mapRow2Val.find(colB);
if (it == mapRow2Val.end()) { // first time
mapRow2Val[colB] = valB*aiv;
}
else {
it->second = it->second + valB*aiv;
}
}
}
}// now column i is created
return true;
}
template <typename R>
bool Mul2Matrices(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB, CSRMatrix<R> &matC)
{
RowMat<R> rowsC;
if( !Mul2Matrices(matA, matB, rowsC) ) return false;
const int k=matB.mNCol;
rowsC.mNCol = k;
CreateCSRMatrixFromRowMap(matC, rowsC); // modified by jianwei hu # 16/09/07
return true;
}
//////////////////////////////////////////////////////////////////////////
// multiplication of sparse matrix
// The result is symmetric
//////////////////////////////////////////////////////////////////////////
template <typename R>
bool Mul2MatricesSymmResult(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB,
RowMat<R> &rowsC)
{
if(matA.onebase() || matB.onebase()){
fprintf(stderr, "\nmatrix saved in 1-based format, pleased converted it to 0-based and try again!");
return false;
}
// Compatibility of dimensions
if(matA.nCol() != matB.nRow() || matA.nRow() != matB.nCol()) return false;
// (m x n)*(n x m) = (m x m)
const int m=matA.nRow();
const int n=matA.nCol();
rowsC = RowMat<R>(m, m); // clean all coefficients
R aiv, valB;
int colInd, colB;
for(int i=0; i<m; ++i) { // creating row i of C
std::map<int, R> &mapRow2Val = rowsC[i];
for (int iAi = matA.mAi[i]; iAi < matA.mAi[i+1]; ++iAi) { // travel on ai
colInd = matA.mAj[iAi];
aiv = matA.mAv[iAi];
// make aiv*b_{colInd} and insert into mapRow2Val
for (int iB=matB.mAi[colInd]; iB<matB.mAi[colInd+1]; ++iB) {
colB=matB.mAj[iB];
if (colB >= i) {
valB=matB.mAv[iB];
// insert valA*aiv into map
std::map<int, R>::iterator it = mapRow2Val.find(colB);
if (it == mapRow2Val.end()) { // first time
mapRow2Val[colB] = valB*aiv;
}
else {
it->second = it->second + valB*aiv;
}
}
}
}
}// now column i is created
return true;
}
template <typename R>
bool Mul2MatricesSymmResult(const CSRMatrix<R> &matA, const CSRMatrix<R> &matB, CSRMatrix<R> &matC)
{
RowMat<R> rowsC;
if( !Mul2MatricesSymmResult(matA, matB, rowsC) ) return false;
rowsC.mNCol = matA.nCol();
CreateCSRMatrixFromRowMap(matC, rowsC);
matC.mMtype = CSRMatrix<R>::RealSymmIndef;
return true;
}
template<typename R>
void DebugShowRowMatrix(const std::vector<std::map<int,R> > &rowA)
{
printf("\n");
for(unsigned int i=0; i<rowA.size(); i++){
printf("\n%3d#", i);
std::map<int,R>::const_iterator it=rowA[i].begin();
int j=0;
for(; it!=rowA[i].end(); ++it){
for(int k=j; k<it->first; k++){
printf("\t%3.2f", 0);
}
j=it->first+1;
printf("\t%3.2f", it->second);
}
}
}
typedef CSRMatrix<float> CSRMatrixf;
typedef CSRMatrix<double> CSRMatrixd;
_NUMC_END
#endif // NUMC_CSRMATRIX_H
Line 123: the CSRMatrix::resize method is undefined, and since CSRMatrix has no base class, it's not inherited.
Line 171: Using a typedef's nested type, like RowType::const_iterator, is a Visual Studio extension, it may not work in other compilers. You should replace these and similar usages with other typedefs, like so:
typedef typename map<int,R>::const_iterator RowTypeConstIterator;
UPDATE: The typename keyword is required (just learned it!)

ld: Symbol(s) not found… but they are there…

My project is really acting up lately - I ironed out a whole bunch of errors, and then it throws a cryptic ld: symbol(s) not found error. However, it's clear that the symbols do exist:
Undefined symbols:
"Solid::~Solid()", referenced from:
void std::_Destroy<Solid>(Solid*)in ui.o
"Log::operator+=(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
"Log::getLog(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
"Log::Log()", referenced from:
__static_initialization_and_destruction_0(int, int)in ui.o
"Building::Building(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
"Log::~Log()", referenced from:
___tcf_1 in ui.o
Here are the files it references:
log.cpp
/*
* log.cpp
*
* Created on: Apr 30, 2011
* Author: wjc
*/
#include <string>
#include <vector>
#include <sstream> // for converting count to string
#include "consts.h"
using namespace std;
struct logResult {
vector <string> result;
int status;
};
struct parsedLog {
string result;
int status;
};
class Log {
private:
bool initialized;
vector <string> * actionLog;
static int count;
string countString(){
stringstream ss;
ss<<count;
return ss.str();
}
public:
int initialize(){
if (initialized) return ALREADY_INIT;
actionLog->push_back("*** Log initialized ***");
actionLog->push_back("This is log#" + countString() +". If this is greater than one, there is a problem.");
initialized = true;
return SUCCESS;
}
int initialize(string text){
int initResult = initialize();
if (initResult == ALREADY_INIT) return ALREADY_INIT;
actionLog->push_back("Initialization message: "+text);
return SUCCESS;
}
Log (){
initialize();
count++;
}
Log (string text){
initialize(text);
count++;
}
~Log (){
count--;
}
bool isInitialized(){
return initialized;
}
int add(string text){
if (!initialized) return NOT_INIT;
actionLog->push_back(text);
return SUCCESS;
}
int operator+= (string text){
return add(text);
}
int clearLog(bool init = true){
if (!initialized) return NOT_INIT;
delete actionLog;
int initResult = SUCCESS;
if (init) initResult = initialize();
if (initResult == ALREADY_INIT) return ALREADY_INIT;
// Otherwise
// (no other possibilities because initialize()
// only returns either a SUCCESS or
// ALREADY_INIT value)
return SUCCESS;
}
logResult getLog(){
if (!initialized){
logResult final;
final.status = NOT_INIT;
return final;
} else {
logResult final;
final.result = *actionLog;
final.status = SUCCESS;
return final;
}
}
parsedLog getLog(string delim){
if (!initialized){
parsedLog final;
final.status = NOT_INIT;
return final;
} else {
parsedLog final;
string logString;
for (unsigned int i; i<actionLog->size()-1; i++){
logString += (*actionLog)[i];
logString += delim;
}
logString += actionLog->back();
final.result = logString;
final.status = SUCCESS;
return final;
}
}
};
log.h
/*
* log.h
*
* Created on: Apr 30, 2011
* Author: wjc
*/
#ifndef LOG_H_
#define LOG_H_
#include <string>
using namespace std;
struct logResult {
vector <string> result;
int status;
};
struct parsedLog {
string result;
int status;
};
class Log {
public:
int initialize();
int initialize(string text);
Log ();
Log (string text);
~Log();
bool isInitialized;
int add(string text);
int operator+= (string text);
int clearLog (bool init = true);
vector <string> getLog();
parsedLog getLog(string delim);
private:
bool initialized;
vector <string> actionLog;
static int count;
string countString();
};
#endif /* LOG_H_ */
ui.cppp
/*
* Created on: Apr 26, 2011
* ui.cpp
* Author: wjc
*/
#include <iostream>
#include <vector>
#include <sstream>
#include "filedaemon.h"
#include "vsystem.h"
#include "customio.h"
#include "building.h"
#include "log.h"
using namespace std;
bool shouldexit = false;
bool back = false;
int selection;
void addShape();
void modifyVars();
struct getVarResult {
var result;
int status;
};
Log actionLog;
var novar = {"ERROR", -1, Reserved};
getVarResult getVar(int type);
void viewBuilding();
int runUI(){
while (!shouldexit){
cout<<"Please select an item from the list below and press Enter:"<<endl;
const int mmenuLength = 2;
string mmenuOptions[2] = {"Create a new document","Quit"};
for (int i=0; i<2; i++){
cout<<i+1<<": "<<mmenuOptions[i]<<endl;
} cout<<endl;
selection = getMenuItem(1,mmenuLength);
if (selection == mmenuLength) return 0; // Quit if it's the last one
cout<<"Enter a name for your building:"<<endl;
string buildingTitle;
getline(cin, buildingTitle);
Building b(buildingTitle);
actionLog += "New building " + buildingTitle + " created.";
const int bmenuLength = 5;
string bmenuOptions[5] = {"Add shape","Modify variables","View building","View log","Quit"};
for (int i=0; i<bmenuLength; i++){
cout<<i+1<<": "<<bmenuOptions[i]<<endl;
} cout<<endl;
selection = getMenuItem(1,bmenuLength);
switch (selection){
case 1:
// Add a shape
break;
case 2:
modifyVars();
break;
case 3:
// View building
break;
case 4:
{
parsedLog parsed = actionLog.getLog("\n");
if (parsed.status == SUCCESS) {
cout<<"The following contains the contents of your action log."<<endl;
cout<<parsed.result<<endl<<endl;
} else {
cout<<"Somehow your log is not initialized."<<endl<<endl;
}
}
break;
case 5:
shouldexit = true;
break;
default:
cout<<"You entered a number greater than "<<bmenuLength<<" or less than 1. How you did this is a mystery."<<endl<<"[ Press Enter to exit ]"<<endl;
string temp;
getline(cin, temp);
return 0;
}
// The following commented-out block is a
// test of the variable storing system.
// It will not be used in any final products.
/*cout << " Variable Systems Test "<<endl;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
cout << endl;
cout<<"Enter a variable name:"<<endl;
string varname;
cin>>varname;
cout<<"Enter a value (A FLOAT!):"<<endl;
float value;
cin>>value;
cout<<"Checking to see if "<<varname<<" exists."<<endl;
bool alreadythere = checkVar(varname);
alreadythere ? cout<<"It exists!"<<endl : cout<<"It doesn't exist."<<endl;
if (alreadythere){
cout<<"Changing variable. Function returned "<<changeVar(varname, value)<<endl;
} else {
cout<<"Setting variable. Function returned "<<addVar(varname, value)<<endl;
}
cout<<"Enter a variable to check:"<<endl;
string varcheck;
cin>>varcheck;
fetchResult result = fetchVar(varcheck);
if(! result.good){
cout<<"Variable \""<<varcheck<<"\" doesn't exist!"<<endl;
} else {
cout<<"Variable \""<<varcheck<<"\" is equal to "<<result.result<<endl;
}
cout<<getVarList("\n","\t")<<endl;
string exitstr;
getch;*/
}
return 0;
}
void modifyVars(){
while (! back){
cout<<"These are your defined variables."<<endl;
cout<<"Reserved variables have an asterisk preceding them."<<endl;
vector <var> vars = getVarList();
for (unsigned int i = 0; i<vars.size(); i++){
cout<<endl;
vars[i].reserved ? cout<<" * " : cout<<" ";
cout << vars[i].name<<" = ";
cout<<fixed<<vars[i].value;
}cout<<endl;
cout<<"What would you like to do?"<<endl;
string varMenuOptions[4] = {"Add a variable","Change a variable","Remove a variable","Go back"};
for (int i = 0; i<4; i++){
cout<<i+1<<". "<<varMenuOptions[i]<<endl;
} cout<<endl;
selection = getMenuItem(1,3);
switch(selection){
case 1: // Add variable
{
getVarResult gvr = getVar(ADD);
if (gvr.status == SUCCESS)
addVar(gvr.result.name, gvr.result.value, UserDefined);
break;
}
case 2: // Change variable
{
getVarResult gvr = getVar(CHANGE);
if (gvr.status == SUCCESS)
changeVar(gvr.result.name, gvr.result.value);
break;
} // switch (selection)
} // while (!back)
}
}
getVarResult getVar(int type){
getVarResult finalResult;
getVarResult invalidType;
getVarResult cancelled;
invalidType.result = novar;
invalidType.status = INVALID_TYPE;
cancelled.result = novar;
cancelled.status = USER_CANCELLED;
if (type != ADD && type != CHANGE) return invalidType;
bool usercancelled = false;
bool nameOK = true;
bool varIsReserved = false;
string varName;
do {
switch(type){
case ADD:
if (!nameOK) cout<<"That variable already exists."<<endl;
break;
case CHANGE:
if (!nameOK) cout<<"That variable has not yet been created."<<endl;
if (varIsReserved) cout<<"That variable is used by the system and cannot be changed."<<endl;
break;
}
cout<<"Enter the variable's name, or \"BACK\": "; varName = getString(1,16);
if (varName == "BACK"){
usercancelled = true;
break;
}
fetchResult testExist = fetchVar(varName);
switch(type){
case ADD:
nameOK = !testExist.good;
break;
case CHANGE:
nameOK = testExist.good;
varIsReserved = testExist.reserved;
break;
default:
cout << "Function error - int type seems to have changed since user called getVar(int type)."<<endl;
cout << "[ Press Enter to exit]"<<endl;
string temp;
getline(cin, temp);
return invalidType;
}
} while (! nameOK || varIsReserved);
finalResult.result.name = varName;
if (usercancelled) return cancelled;
bool valueOK = true;
float numValue;
do {
if (! valueOK) cout<<"That doesn't seem to be a valid positive number.";
cout<<"Enter the new value, or \"COPY\" to copy a variable, or \"BACK\":"<<endl;
string value = getString();
/*
* If "BACK" then break do-while(! valueOK)
*/
if (value == "BACK"){
usercancelled = true;
break;
}
if(value == "COPY"){
string copyVar;
fetchResult varContents;
bool copyOK = true;
do {
if (!copyOK) cout<<"That variable does not exist. Note that names are case-sensitive."<<endl;
cout<<"Enter the variable to copy, \"VIEW\" to view all, or \"BACK\":"<<endl;
/*
* If "BACK" then break do-while(! valueOK)
*/
if (value == "BACK"){
usercancelled = true;
break;
}
copyVar = getString(1,8);
if (copyVar == "VIEW") {
cout<<"Your current variables are as follows:"<<endl;
vector <var> vars = getVarList();
for (unsigned int i = 0; i<vars.size(); i++){
cout<<endl;
vars[i].reserved ? cout<<" * " : cout<<" ";
cout << vars[i].name<<" = ";
cout<<fixed<<vars[i].value;
}cout<<endl;
} else {
varContents = fetchVar(copyVar);
copyOK = varContents.good;
numValue = varContents.result;
}
} while (copyVar == "VIEW" || ! copyOK);
} else {
// This code converts from string to number safely.
stringstream testStream(value);
if (! (testStream >> numValue))
valueOK = false;
}
if (! usercancelled) break;
} while (! valueOK);
finalResult.result.value = numValue;
if (usercancelled) return cancelled;
finalResult.status = SUCCESS;
return finalResult;
}
ui.h
/*
* ui.h
*
* Created on: Apr 26, 2011
* Author: wjc
*/
#ifndef UI_H_
#define UI_H_
#include "vsystem.h"
int runUI();
void addShape();
void modifyVars();
struct getVarResult {
var result;
int status;
};
getVarResult getVar(int type);
void viewBuilding();
#endif /* UI_H_ */
building.h
/*
* building.h
*
* Created on: Apr 30, 2011
* Author: wjc
*/
#ifndef BUILDING_H_
#define BUILDING_H_
#include <string>
#include <vector>
#include "consts.h"
#include "solid_type.h"
using namespace std;
struct dimension {
bool exists;
float value;
};
class Solid {
public:
string name;
string comment;
solid_type type;
bool positive;
dimension dim1; // Radius, width, or side length
dimension dim2; // Height, number of sides, or fraction of sphere_over_n
dimension dim3; // Width - only for prism_rect, pyrm_rect and tprym_rect
Solid ();
Solid (bool pos);
Solid (string setName, string setComment, solid_type setType, bool setPos, dimension setDim1,
dimension setDim2, dimension setDim3);
~Solid();
int countShapes();
int howMany();
private:
static int count;
};
class Building {
private:
string name;
vector <Solid> components;
public:
Building(string text);
void setName(string text);
string getName();
vector <Solid> addComponent(Solid component);
};
#endif /* BUILDING_H_ */
building.cpp
/*
* building.cpp
*
* Created on: May 1, 2011
* Author: wjc
*/
#include <string>
#include <vector>
#include "consts.h"
#include "solid_type.h"
using namespace std;
struct dimension {
bool exists;
float value;
};
class Solid{
public:
string name; // So the user can look at the log
string comment; // Expanded version of name, again for the log
solid_type type; // Determines the type of Solid
bool positive; // Positive = addition; negative = subtraction
dimension dim1; // Radius, width, or side length
dimension dim2; // Height, number of sides, or fraction of sphere_over_n
dimension dim3; // Width - only for prism_rect, pyrm_rect and tprym_rect
Solid(){
count++;
}
Solid(bool setPos){
count++;
positive = setPos;
}
Solid (string setName, string setComment, solid_type setType, bool setPos, dimension setDim1,
dimension setDim2, dimension setDim3){
count++;
name = setName;
comment = setComment;
type = setType;
positive = setPos;
dim1 = setDim1;
dim2 = setDim2;
dim3 = setDim3;
}
~Solid(){
count--;
}
int howMany(){
return count;
}
int countSolids(){
return howMany();
}
private:
static int count; // Number of Solids in existence
};
class Building {
private:
string name;
vector <Solid> components;
public:
Building (string text){
setName(text);
}
void setName(string text) {
name = text;
}
string getName(){
return name;
}
vector <Solid> addComponent(Solid component){
components.push_back(component);
return components;
}
};
My complete code is available at FileDropper, although I know most people won't want to unpack a zip, so I put the relevant ones above.
Any help would be greatly appreciated!
Running Eclipse Helios with G++ 4.2.1 on Mac OS X Snow Leopard 10.6.7.
The complete linking command is:
g++ -o "BuildingGenerator" ./src/bgmath.o ./src/building.o ./src/customio.o \
./src/filedaemon.o ./src/log.o ./src/main.o ./src/ui.o ./src/vsystem.o
So it looks like it is linking all the necessary files. Also, the (header) files are all #include'd where needed.
Problem discovered; outline fix created...
Code received, unpacked, and compiled; the linker produces essentially the same error that you're seeing...
Osiris-8 JL: make bgmath.o building.o customio.o filedaemon.o log.o main.o ui.o vsystem.o
g++ -c -o bgmath.o bgmath.cpp
g++ -c -o building.o building.cpp
g++ -c -o customio.o customio.cpp
g++ -c -o filedaemon.o filedaemon.cpp
g++ -c -o log.o log.cpp
g++ -c -o main.o main.cpp
g++ -c -o ui.o ui.cpp
g++ -c -o vsystem.o vsystem.cpp
Osiris-8 JL: g++ -o cmd *.o
Undefined symbols for architecture x86_64:
"Building::Building(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
"Log::operator+=(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
"Log::getLog(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
"Log::Log()", referenced from:
__static_initialization_and_destruction_0(int, int) in ui.o
ld: symbol(s) not found for architecture x86_64
collect2: ld returned 1 exit status
Osiris-8 JL:
This is on MacOS X 10.6.7 with GCC 4.6.0 (which I compiled). Since it is substantially the same as what you got, the version of G++ is essentially irrelevant (but not wholly; the c++filt distributed along with GCC 4.2.1 by Apple does not recognize the 'nm' output you provided, even after cleaning the BOM out of the file).
OK - several grey hairs later - I know roughly what is going on.
When I run nm log.o, it said 'nm: no name list'. That's because it is, in fact, an empty object file. And it is an empty object file because all the code is in a class declaration, but is never used so there is no object code in the file, and no functions.
I had a suspicion that it was something to do with definitions - I had not guessed it was as completely 'no defined functions' as it is.
So, how do we fix it?
The first problem is that you have log.cpp but it does not include log.h. This is a strong indicator of problems. The header defines the public interface to the class(es) defined in the source, and the only (sane) way of ensuring they are in agreement is to include the header in the source file. In fact, it is best to include the header first so that you can be sure it is self-contained (can be used in any source module).
When we do that, we find immediately that log.h is not self-contained -- it needs #include <vector> too. When that's fixed, we find that you cannot compile log.cpp successfully:
g++ -c -o log.o log.cpp
log.cpp:12:8: error: redefinition of ‘struct logResult’
log.h:15:8: error: previous definition of ‘struct logResult’
log.cpp:17:8: error: redefinition of ‘struct parsedLog’
log.h:20:8: error: previous definition of ‘struct parsedLog’
log.cpp:22:7: error: redefinition of ‘class Log’
log.h:25:7: error: previous definition of ‘class Log’
make: *** [log.o] Error 1
The two structures are declared in the header, so they should not be redeclared in the source. The function definitions must be prefixed with Log:: and removed from the 'class Log { ... }' braces. There is then routine clean up of the compilation errors, leading to:
log.h
#ifndef LOG_H_
#define LOG_H_
#include <vector>
#include <string>
using namespace std;
struct logResult {
vector <string> result;
int status;
};
struct parsedLog {
string result;
int status;
};
class Log {
public:
int initialize();
int initialize(string text);
Log ();
Log (string text);
bool isInitialized();
int add(string text);
int operator+= (string text);
int clearLog (bool init = true);
logResult getLog();
parsedLog getLog(string delim);
private:
bool initialized;
vector <string> actionLog;
};
#endif /* LOG_H_ */
log.cpp
#include "log.h"
#include "consts.h"
using namespace std;
int Log::initialize(){
if (initialized) return ALREADY_INIT;
actionLog.push_back("*** Log initialized ***");
initialized = true;
return SUCCESS;
}
int Log::initialize(string text){
if (initialized) return ALREADY_INIT;
// otherwise...
initialize();
actionLog.push_back("Initialization message: "+text);
return SUCCESS;
}
Log::Log (){
initialize();
}
Log::Log (string text){
initialize(text);
}
bool Log::isInitialized(){
return initialized;
}
int Log::add(string text){
if (!initialized) return NOT_INIT;
actionLog.push_back(text);
return SUCCESS;
}
int Log::operator+= (string text){
return add(text);
}
int Log::clearLog(bool init){
if (!initialized) return NOT_INIT;
//delete actionLog;
initialized = false;
if (init) return initialize();
// Else
return SUCCESS;
}
logResult Log::getLog(){
if (!initialized){
logResult final;
final.status = NOT_INIT;
return final;
} else {
logResult final;
final.result = actionLog;
final.status = SUCCESS;
return final;
}
}
parsedLog Log::getLog(string delim){
if (!initialized){
parsedLog final;
final.status = NOT_INIT;
return final;
} else {
parsedLog final;
string logString;
for (unsigned int i; i<actionLog.size()-1; i++){
logString += actionLog[i];
logString += delim;
}
logString += actionLog.back();
final.result = logString;
final.status = SUCCESS;
return final;
}
}
These files compile cleanly to generate log.o containing some useful functions. The link failure after that is:
Undefined symbols for architecture x86_64:
"Building::Building(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)", referenced from:
runUI() in ui.o
ld: symbol(s) not found for architecture x86_64
collect2: ld returned 1 exit status
Fixing that is left as an exercise for you - but I believe analogous changes are needed in building.h and building.cpp.
There are still some issues that should be resolved. In particular, headers should not usually do using namespace std; as that is an unwarranted intrusion into other programmer's control over the namespaces they use. See Using namespace in C++ headers for a recent discussion of this issue.