Ошибка линкера - C++ - Ответ 3295407

#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;
char *p_buf; // points to start of program
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
}
 
// Display an error message.
void serror(errorsT error)
{
  char *p, *temp;
  int linecount = 0;
  register int i;
 
  static char *e[]= {   
    "Syntax error", 
    "Unbalanced parentheses", 
    "No expression present",
    "Division by zero",
    "Equal sign expected",
    "Not a variable",
    "Label table full",
    "Duplicate label",
    "Undefined label",
    "THEN expected",
    "TO expected",
    "Too many nested FOR loops",
    "NEXT without FOR",
    "Too many nested GOSUBs",
    "RETURN without GOSUB",
    "Double qoutes needed"
  }; 
  cout << e[error]; 
 
  p = p_buf;
  while(p != prog) {  // find line number of error 
    p++;
    if(*p == '\r') {
      linecount++;
    }
  }
  cout << " in line " << linecount << ".\n";
 
  temp = p;  // display line with error
  for(i=0; i<20 && p>p_buf && *p!='\n'; i++, p--);
  for(; p<=temp; p++) cout << *p;
    
  throw(1); // throw an exception
}
// CONSTANTS
/*
if(isalpha(*prog) && strstr(prog,"const")) {
    while(*prog != 't') *prog++;*prog++;
    while(is_sp_tab(*prog))*prog++;
    *temp++ = *prog++;
    tok_type = CONSTANT;
  }
  */