Ошибка Линкера 2

  • Автор темы DenisNN
  • Дата начала
D

DenisNN

Гость
#1
Здравствуйте!!! Подскажите пожалуйста почему возникают ошибки линкера?
C++:
// main.cpp

#include "parser.h"

int main()
{
char prog_buff[PROG_SIZE];

load_program(prog_buff,"E:/projects/vars_test.dci");
//getch();
return 0;
}[/CODE]

C++:
// parser.h

#pragma once

#include "constants_list.h"
#include "variables_list.h"

const int PROG_SIZE = 10000;

// The DCI command tokens.
enum DCItokensT { UNKNCOM, PRINT, INPUT, IF, THEN, FOR, NEXT, TO,
GOTO, GOSUB, RETURN, EOL, FINISHED, END };
// The DCI token types.
enum typesT { UNDEFTOK, OPERATOR, NUMBER, VARIABLE, COMMAND,
STRING, QUOTE };

/* These are the constants used to call serror() when
a syntax error occurs. Add more if you like.
NOTE: SERROR is a generic error message used when
nothing else seems appropriate. */
enum errorsT { SERROR, PARENS, NOEXP, DIV_ZERO, EQUAL_EXP,
NOT_VAR, LAB_TAB_FULL, DUP_LAB, UNDEF_LAB,
THEN_EXP, TO_EXP, TOO_MNY_FOR, NEXT_WO_FOR,
TOO_MNY_GOSUB, RET_WO_GOSUB, MISS_QUOTE };

// check for double op
enum double_ops { LE, GE, NE };

// keyword lookup table
/*
struct commands { 
char command[20]; // string form 
DCItokensT tok; // internal representation 
} table[] = { // commands must be entered lowercase 
"print", PRINT, // in this table. 
"input", INPUT,
"if", IF,
"then", THEN,
"goto", GOTO,
"for", FOR,
"next", NEXT,
"to", TO,
"gosub", GOSUB,
"return", RETURN,
"end", END,
"", END // mark end of table 
};*/

char *prog;
typesT tok_type;
DCItokensT tok;
char token[20];

class parser
{
void serror(errorsT);
DCItokensT look_up(char*); // convert to internal rep 
typesT get_token();

public:
parser();
~parser();

bool isdelim(char);
bool is_sp_tab(char);
};

typesT parser::get_token()
{
register char *temp;

tok_type = UNDEFTOK;
temp = token;
*temp = '\0';

if(*prog=='\0') { // end of file 
*token = '\0';
tok = FINISHED;
return(tok_type=OPERATOR);
}

if(*prog=='\r') 
{ // crlf 
++prog; ++prog;
return(tok_type = OPERATOR);
}
while(is_sp_tab(*prog)) ++prog; // skip over white space

if(strchr("+-%*/^=()", *prog)){ 
tok_type = OPERATOR;
// advance to next char
*temp++ = *prog++;
}

if(strchr("<>", *prog)) { // check for double op
switch(*prog) {
case '<':
if(*(prog+1)=='>') {
prog++; prog++;
*temp = NE;
}
else if(*(prog+1)=='=') {
prog++; prog++;
*temp = LE;
}
else {
prog++;
*temp = '<';
}
temp++;
*temp = '\0';
break;
case '>':
if(*(prog+1)=='=') {
prog++; prog++;
*temp = GE;
}
else {
prog++;
*temp = '>';
}
temp++;
*temp = '\0';
break;
}
return(tok_type = OPERATOR);
}
if(strchr("+-*^/=;(),", *prog)){ // operator
*temp = *prog;
prog++; // advance to next position 
temp++;
*temp = '\0'; 
return (tok_type=OPERATOR);
}

if(*prog=='"') { // quoted string 
prog++;
while(*prog!='"'&& *prog!='\r') *temp++ = *prog++;
if(*prog=='\r') serror(MISS_QUOTE);
prog++; *temp = '\0';
return(tok_type=QUOTE);
}

if(isdigit(*prog)) { // number 
while(!isdelim(*prog)) *temp++ = *prog++;
*temp = '\0';
return(tok_type = NUMBER);
}

if(isalpha(*prog)) { // var or command 
while(!isdelim(*prog)) *temp++ = *prog++;
tok_type = STRING;
}

*temp = '\0';

// see if a string is a command or a variable 
if(tok_type==STRING) {
tok = look_up(token); // convert to internal rep 
if(!tok) tok_type = VARIABLE;
else tok_type = COMMAND; // is a command 
}
return tok_type;
}
/*





/*
if(isalpha(*prog) && strstr(prog,"const")) {
while(*prog != 't') *prog++;*prog++;
while(is_sp_tab(*prog))*prog++;
*temp++ = *prog++;
tok_type = CONSTANT;
}
else if(isalpha(*prog)) {
while(!isdelim(*prog)) *temp++ = *prog++;
return(tok_type = VARIABLE);
} 
else if(isdigit(*prog)) {
while(!isdelim(*prog)) *temp++ = *prog++;
return(tok_type = NUMBER);
}

*temp = '\0';
}*/

// Return true if c is a delimiter. 
bool parser::isdelim(char c)
{
if(strchr(";,+-<>/*%^=()", c) || c==9 || c=='\r' || c==0) 
return true; 
return false; 
}

// Return true if c is space or tab. 
bool parser::is_sp_tab(char c)
{
if(c==' ' || c=='\t') return true;
else return false;
}

// Load a program.
bool load_program(char *p, char *fname)
{
ifstream in(fname, ios::in | ios::binary);
int i=0;
prog = p;
if(!in) {
cout << "File not found ";
cout << "-- be sure to specify .BAS extension.\n";
return false;
}

i = 0;
do {
*p = in.get();
p++; i++;
} while(!in.eof() && i<PROG_SIZE);

// null terminate the program
if(*(p-2)==0x1a) *(p-2) = '\0'; // discard eof marker
else *(p-1) = '\0';

in.close();
return true;
}
/* Look up a token's internal representation in the
token table.


DCItokensT look_up(char *s)
{
register int i;
char *p;

// convert to lowercase 
p = s;
while(*p){ 
*p = tolower(*p);
p++;
}

// see if token is in table 
for(i=0; *table[i].command; i++)
if(!strcmp(table[i].command, s))
return table[i].tok;
return UNKNCOM; // unknown command
}*/
// CONSTANTS
/*
if(isalpha(*prog) && strstr(prog,"const")) {
while(*prog != 't') *prog++;*prog++;
while(is_sp_tab(*prog))*prog++;
*temp++ = *prog++;
tok_type = CONSTANT;
}
*/
C++:
//variables_list.h

#pragma once

#include "header.h"

const int SIZE_OF_NAME_C = 20;

class vars_list
{
class node
{

friend class vars_list;

char name[SIZE_OF_NAME_C];
double value;
node *next;
node *prev;

public:
node(){value = 0;}
node(double vl):value(vl)
{ }
~node(){}	
};

public:

node *head;
node *tayl;

vars_list(){}
~vars_list(){}

void create();				// create empty list
void add_var(char*,double); // add variable
bool exist(char*);		 // if exist

};


///////////////////////////////////////////////////
bool vars_list::exist(char *name)
{

node *pHead = head;

while(pHead != tayl)
if(strstr(name,pHead->name))
return true;
else
pHead = pHead->next;
return false;
}
///////////////////////////////////////////////////
void vars_list::create()
{
head = tayl = new node;

head->next = tayl;
tayl->next = 0;
tayl->prev = 0;

}
///////////////////////////////////////////////////
void vars_list::add_var(char *name,double var)
{
node *pnode = new node(var);
pnode->next = head;
pnode->prev = 0;
head->prev = pnode;
head = pnode;

int i = 0;
while(isalpha(*name))
{
head->name[i] = *name;
i++; *name++;
}
head->name[i] = '\0';
}
C++:
//constants_list.h

#pragma once

#include "header.h"

const int SIZE_OF_NAME_V = 20;

class const_list
{
class node
{

friend class const_list;

char name[SIZE_OF_NAME_V];
double value;
node *next;
node *prev;

public:
node(){value = 0;}
node(double vl):value(vl)
{ }
~node(){}	
};

public:

node *head;
node *tayl;

const_list(){}
~const_list(){}

void create();				// create empty list
void add_var(char*,double); // add variable
bool exist(char*);		 // if exist

};


///////////////////////////////////////////////////
bool const_list::exist(char *name)
{

node *pHead = head;

while(pHead != tayl)
if(strstr(name,pHead->name))
return true;
else
pHead = pHead->next;
return false;
}
///////////////////////////////////////////////////
void const_list::create()
{
head = tayl = new node;

head->next = tayl;
tayl->next = 0;
tayl->prev = 0;

}
///////////////////////////////////////////////////
void const_list::add_var(char *name,double var)
{
node *pnode = new node(var);
pnode->next = head;
pnode->prev = 0;
head->prev = pnode;
head = pnode;

int i = 0;
while(isalpha(*name))
{
head->name[i] = *name;
i++; *name++;
}
head->name[i] = '\0';
}
C++:
// header.h

#pragma once

#include <iostream>
#include <fstream>
#include <conio.h>

using namespace std;