Форум программистов, компьютерный форум CyberForum.ru

Пишем свой интерпретатор языка BASIC - C++

Восстановить пароль Регистрация
Другие темы раздела
C++ Меню и список http://www.cyberforum.ru/cpp-beginners/thread41194.html
Здравствуйте форумчане. Помоги пожалуйста в следующем вопросе: У меня есть 2связный список, написано меню. Но в моменте когда написано make a list и delete custom необходимо чтобы выводились: Введите элемент и номер. вот сам код: #ifndef __list_h #define __list_h #include <iostream>
C++ Здравствуйте! Не могу поместить class в один файл с программой. file.hpp #include "Cat.hpp" // здесь классы "2)" Cat::Cat(int initialAge) { itsAge = initialAge; } Cat::~Cat() { http://www.cyberforum.ru/cpp-beginners/thread41186.html
Массивы строк C++
Привет всем! Задан массив строк. Как узнать который символ встечаетса найбольшое количество раз в етом массиве?
C++ вывод на экран набор треугольников и квадратов, которые произвольно двигаются и меняют размер
Please, help me!!! Вот текст программы, которая выводит на экран набор треугольников и квадратов, которые произвольно двигаются и меняют размер только квадратов. Проблема в том, что необходимо исправить код, чтоб фигуры не исчезали за экран (т.е. 640х460) и были компактным набором, т.е. двигались неменяя своего положения относительно друг друга и стукаясь об стенку экрана меняли свое...
C++ Округление дробного числа до целого в большую сторону. http://www.cyberforum.ru/cpp-beginners/thread41139.html
Доброго дня. Я новичок в программирование на Visual C++. Проблема такая программа должна считать кол-во месяцев, если числа целые то программа шла дальше, если дробное то (например 3.33333) программа не округляет это число (в большую сторону) до 4. Перелопатил тонны литературы, но пропустил или не нашёл этого, большая просьба написать функцию которая могла бы это делать, или способ какой.
C++ Код из Delphi в C++ Нужно написать курсовую на C++. Сам я в программировании плохо шарю (не программист). Попросил у народу помощи, помогли. Но решение на Delphi: {$APPTYPE CONSOLE} type byteset=set of byte; var d:array of longint; procedure c; var a,b,i:longint; подробнее

Показать сообщение отдельно
#pragma
Временно недоступен
 Аватар для #pragma
952 / 223 / 6
Регистрация: 12.04.2009
Сообщений: 921
29.06.2009, 01:02  [ТС]     Пишем свой интерпретатор языка BASIC
Хотел уточнить свои слова насчёт проблемы с вызовом функций(ну очень хочется доделать)
Цитата Сообщение от Evg Посмотреть сообщение
Поясни на конкретном примере, а то в общих словах я ничего не понял
В-общем как я понимаю в данном конкретном случае проблема сводится к тому,как правильно послать готовую строку (которую я уже приготовил для вычисления,например "a*b") обратно в поток ввода.То есть у меня получается что когда из функции get_token() возвращается значение FUNC,за этим следует вызов expr(true) с последующими вызовами get_token(),но в потоке для чтения нет строки,которую я приготовил и отослал функцией putback в строке 342: source.putback(::result_expr[j]); В итоге при прилагаемых входных данных программа печатает 'a',которая следует за именем функции и находится в списке параметров,а моя готовая строка ещё до этого куда-то девается..Вот я думаю может я неправильно это сделал(в смысле работал с потоком)?
Вот прилагаю исходник,если не лень поглядеть,конечно.А насчёт svn это в интернете репозиторий создается,навроде как в launchpad сделано?Бесспорно,это удобнее...есть ещё cvs какой-то.
main.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include "LexicalAnalyzer.h"
#include "error_handler.h"
 
 
int main()
{
    table["pi"]=3.1415926535897932385;
    table["e"]=2.7182818284590452354;
    source.open("program.clc",std::ifstream::in);
    while (source.good()) {
        get_token();
        if (err_state==GLOBAL_ERROR)break;
        if (curr_tok==END) break;
        if (curr_tok==PRINT) continue;
        double x=expr(false);
        if (print_var==PRINT_VAR)
        {
           std::cout<<x<<'\n';
           print_var = DONT_PRINT_VAR;
        }
    }
    source.close();
    return 0;
}

LexicalAnalyzer.h
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
#ifndef LEXICALANALYZER_H_INCLUDED
#define LEXICALANALYZER_H_INCLUDED
 
#include <cctype>
#include <string>
#include <map>
#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <fstream>
 
extern std::ifstream source;
 
enum Token_value {
    NAME,       NUMBER,      END,       FUNC = '$',
    PLUS = '+', MINUS = '-', MUL = '*', DIV = '/',
    PRINT = ';',ASSIGN = '=',LP = '(',  RP = ')',
    AND = '&',  XOR = '^',   OR = '|',  NOT = '~',
    BEGIN_FUNC = '@',COMMENT = '"'
};
 
enum Printer_state {
    PRINT_VAR,DONT_PRINT_VAR
};
 
 
 
typedef std::map<std::string,int>Map_of_names;
typedef std::map<std::string,double>Map_of_table;
 
extern Token_value curr_tok;
extern Printer_state print_var;
 
extern std::map<std::string,double>table;
extern std::vector<std::string>initialized_vars;
extern std::string string_value;
 
extern std::map<std::string,int>func_name;
extern std::vector<std::string>func_value;
extern std::map<std::string,int>func_num_of_param;
extern std::string result_expr;
extern std::string get_resulting_expr(std::string,std::string,std::string,int);
 
 
Token_value get_token();
 
double expr(bool);
double term (bool);
double prim (bool);
 
 
 
#endif // LEXICALANALYZER_H_INCLUDED

LexicalAnalyzer.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
#include "LexicalAnalyzer.h"
#include "error_handler.h"
 
 
std::map<std::string,double>table;
Token_value curr_tok = PRINT;
Printer_state print_var = DONT_PRINT_VAR;
double expr (bool get)
{
    double left = term(get);
 
    for (;;)
        switch (curr_tok) {
            case PLUS:
                 left += term(true);
            break;
            case MINUS:
                 left -= term(true);
            break;
            default:
                 return left;
        }
}
 
double term (bool get)
{
    double left = prim (get);
 
    for (;;)
        switch (curr_tok) {
            case MUL:
                 left *= prim(true);
            break;
            case DIV:
                 if (double d = prim (true)) {
                     left /= d;
                     break;
                 }
                 return error(divide_by_zero);
            case AND:
                 if (err_state != BIN_TO_DOUBLE)
                 {
                     left = static_cast<int>(left) & static_cast<int>(prim(true));
                     break;
                 }
                 return error(binary_to_double);
            case XOR:
                 if (err_state != BIN_TO_DOUBLE)
                 {
                     left = static_cast<int>(left) ^ static_cast<int>(prim(true));
                     break;
                 }
                 return error(binary_to_double);
            case OR:
                 if (err_state != BIN_TO_DOUBLE)
                 {
                     left = static_cast<int>(left) | static_cast<int>(prim(true));
                     break;
                 }
                 return error(binary_to_double);
            default:
                 return left;
        }
}
 
double number_value;
std::string string_value;
std::map<std::string,int>func_name;
std::vector<std::string>func_value;
std::map<std::string,int>func_name_to_param;
std::vector<std::string>initialized_vars;
std::string result_expr;
std::ifstream source;
int string_number=0;
 
double prim (bool get)
{
    if (get) get_token();
    switch (curr_tok){
 
        case NUMBER:{
                    double& v = ::number_value;
                    get_token();
                    if (curr_tok==LP)
                        return error(wrong_expression);
                    return v;
        }
        case NAME:{
                    double& v = table[::string_value];
                    if (get_token()==ASSIGN)
                    {
                        ::initialized_vars.push_back(::string_value);
                        v = expr(true);
                        return v;
                    }
                    else
                    {
                        int i = count(::initialized_vars.begin(),::initialized_vars.end(),::string_value);
                        if (i == 0)
                        {
                            table.erase(::string_value);
                            return error(unknown_variable,::string_value);
                        }
                    }
                    return v;
        }
        case MINUS:
                   return -prim(true);
        case NOT:{
                   if (err_state != BIN_TO_DOUBLE)
                   {
                       int e = ~static_cast<int>(prim(true));
                       if (err_state == BIN_TO_DOUBLE)
                       {
                            return error(binary_to_double);
                       }
                       return static_cast<double>(e);
                   }
                   else
                       return error(binary_to_double);
        }
        case LP:{
                   double e = expr(true);
                   if (curr_tok!=RP)
                       return error(lp_expected);
                   get_token();
                   return e;
        }
        case FUNC:{
                   double e = expr(true);
                   return e;
        }
        case COMMENT:
                     get_token();
                     return 0;
        default:
                  return error(primary_expr_expected);
    }
}
 
Token_value get_token()
{
    char ch = 0;
 
 
    if (curr_tok == COMMENT)
        do {
               if (!source.get(ch))
               return curr_tok = END;
 
           }
        while (ch!='\n');
    /*if (curr_tok == FUNC)
        do {
               if (!source.get(ch))
               return curr_tok = END;
 
           }
        while (ch!='\n');*/
    do {
        if (!source.get(ch)) return curr_tok = END;
 
    } while (ch!='\n'&&isspace(ch));
 
    switch (ch) {
        case 0:
                 return curr_tok = END;
 
        case ';':
                 return curr_tok = PRINT;
 
        case '\n':
                 ++string_number;
                 return curr_tok = PRINT;
 
        case '"':return curr_tok =COMMENT;
 
        case '*':case '/':case '+':case '-':case '(':case ')':
        case '=':case '~':case '&':case '^':case '|':
                 return curr_tok=Token_value(ch);
 
        case '0':case '1':case '2':case '3':case '4' :
        case '5':case '6':case '7':case '8':case '9':
                 source.putback(ch);
                 source>>number_value;
                 if(number_value-static_cast<int>(number_value)!=0)
                 err_state = BIN_TO_DOUBLE;
                 return curr_tok = NUMBER;
 
        case ',':return curr_tok = PRINT;
 
        case '#':
                 print_var = PRINT_VAR;
                 return curr_tok = PRINT;
 
        case '@':{
                 // Writing whole string to build a function.
                 // @ - reserved sign for start user function
                 // programming.
 
                 // Copying whole function string to tmp
                 std::string tmp;
                 tmp = ch;
                 while (source.get(ch)&&ch!='\n') tmp.push_back(ch);
                 source.putback(ch);
 
                 // Set useful places in the string
                 unsigned int i = find(tmp.begin(),tmp.end(),'(')-tmp.begin();
                 unsigned int k = find(tmp.begin(),tmp.end(),')')-tmp.begin();
 
                 // There must be parameters list in the function
                 if (i==tmp.size()||k==tmp.size())
                 {
                     error("Ожидался список параметров");
                     return curr_tok = PRINT;
                 }
 
                 // Checking function name for previous declaration
                 std::string s = tmp.substr(1,i-1);
                 Map_of_names::iterator it = ::func_name.find(s);
                 if (it != ::func_name.end())
                 {
                     error("Повторное определение функции");
                     return curr_tok = PRINT;
                 }
                 else
                 {
                    // Declaration
                    unsigned int j = find(tmp.begin(),tmp.end(),'{')-tmp.begin();
 
                    // Function must have body
                    if (j==tmp.size())
                    {
                        error("Ожидалась {");
                        return curr_tok = PRINT;
                    }
 
                    // Not empty body
                    if (tmp.substr(j+1,tmp.size()-j-2).size()<1)
                    {
                        error("Пустая функция");
                        return curr_tok = PRINT;
                    }
 
                    // At start of parameters list,as at the end,
                    // have to be an alphabet character
                    std::string param_list = tmp.substr(i+1,k-i-1);
                    if (isalpha(param_list.at(0))&&isalpha(param_list[param_list.size()-1]))
                    {
                        // Function template creation
                        ::func_name_to_param[s] = count(param_list.begin(),param_list.end(),',')+1;
                        ::func_name[s];
                        ::func_value.push_back(tmp.substr(i,tmp.size()-i));
                        return curr_tok = PRINT;
                    }
                    else
                    {
                        error("Неправильный список параметров");
                        return curr_tok = PRINT;
                    }
                 }
                 return curr_tok = PRINT;
             }
        case '}':case '{':{
                 // End of user function
                 source.putback(ch);
                 return curr_tok = PRINT;
             }
        case '$':{
                 // $ - reserved for starting to calculate
                 // function that was programmed before
 
                 // Writing function with parameters
                 // that we need to calculate to tmp
                 std::string tmp;
                 tmp = ch;
 
                 while (source.get(ch)&&(ch != '\n')) tmp.push_back(ch);
                 source.putback(ch);
 
                 // Set useful places in the string
                 unsigned int i = find(tmp.begin(),tmp.end(),'(')-tmp.begin();
                 unsigned int k = find(tmp.begin(),tmp.end(),')')-tmp.begin();
 
                 // Checking for function was declared before
                 std::string nm_tmp = tmp.substr(1,i-1);
                 Map_of_names::iterator it = ::func_name.find(nm_tmp);
                 if (it == ::func_name.end())
                 {
                     error("Функция не была объявлена ранее");
                     return curr_tok = PRINT;
                 }
                 else
                 {
                     std::string param_list = tmp.substr(i+1,k-i-1);
                     if (isalnum(param_list[0])&&isalnum(param_list[param_list.size()-1]))
                     {
                         // Count parameters and checking amount of
                         // parameters in declared function
                         int param_count = count(param_list.begin(),param_list.end(),',')+1;
                         if (param_count> ::func_name_to_param[nm_tmp]||
                             param_count< ::func_name_to_param[nm_tmp])
                         {
                             error("Неправильное количество параметров функции");
                             return curr_tok = PRINT;
                         }
                         ///////////////////////////////////////////
                         /**  Our function is "OK".               */
                         ///////////////////////////////////////////
                         std::string main_param_list = ::func_value[::func_name[nm_tmp]].substr(1,
                                                                                         ::func_value[::func_name[nm_tmp]].find_first_of(')',1)-1);
 
                         ::result_expr = get_resulting_expr(param_list,
                                                            main_param_list,
                                                            ::func_value[::func_name[nm_tmp]],
                                                            ::func_name_to_param[nm_tmp]);
                        // ::result_expr.push_back('\n');
 
                         for (int j = ::result_expr.size(); j >= 0; --j)
                         source.putback(::result_expr[j]);
                         return  curr_tok = FUNC;
 
                     }
                     else
                     {
                         error("Неверный параметр функции");
                         return curr_tok = PRINT;
                     }
                 }
                 return curr_tok = PRINT;
             }
        default:
             if (isalpha(ch)) {
                 ::string_value = ch;
                 while (source.get(ch)&&isalnum(ch)) ::string_value.push_back(ch);
                 source.putback(ch);
                 return curr_tok = NAME;
             }
             error (wrong_expression);
             return curr_tok = PRINT;
    }
}

error_handler.h
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#ifndef ERROR_HANDLER_H_INCLUDED
#define ERROR_HANDLER_H_INCLUDED
 
#include <string>
#include <iostream>
 
enum Error_state {
    BIN_TO_DOUBLE,NO_ERRORS,
    GLOBAL_ERROR
};
 
extern Error_state err_state;
 
 
const std::string divide_by_zero        = "Деление на ноль";
const std::string binary_to_double      = "Битовые операции могут выполняться только над целыми типами";
const std::string unknown_variable      = "Неинициализированная переменная";
const std::string lp_expected           = "Ожидалась )";
const std::string primary_expr_expected = "Ожидалось первичное выражение";
const std::string wrong_expression      = "Неправильная лексема";
 
extern int string_number;
 
int error(const std::string&);
int error(const std::string,const std::string);
 
#endif // ERROR_HANDLER_H_INCLUDED

error_handler.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include "LexicalAnalyzer.h"
#include "error_handler.h"
 
Error_state err_state = NO_ERRORS;
 
int error(const std::string& s)
{
    ++string_number;
    ::err_state=GLOBAL_ERROR;
    ::print_var = DONT_PRINT_VAR;
    std::cerr<<"Строка: "<< ::string_number<<" Ошибка: "<<s<<'\n';
    return 0;
}
int error(const std::string s,const std::string v)
{
    ++string_number;
    err_state=GLOBAL_ERROR;
    print_var = DONT_PRINT_VAR;
    std::cerr<<"Строка: "<< ::string_number
             <<" Ошибка: "<<s<<' '<<"'"<<v<<"'"<<'\n';
    return 0;
}

param_swapper.cpp
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
#include "LexicalAnalyzer.h"
 
// Function get parameters and temlate in
// strings of two functions and returns
// resulting string as expression for
// future calculation
// Просто жесть
 
std::string get_resulting_expr(std::string s_son_par,
                               std::string s_father_par,
                               std::string s_father_expr,
                               int param_count)
{
    std::string resulting_expr;
    if (param_count==1)
    {
        //To be continued?
    }
    else
    {
        // Store parameters
        std::vector<std::string>tmp_son_par;
        std::vector<std::string>tmp_father_par;
 
        // Using iterators to find parameters
        std::string::iterator iter_s_son = find(s_son_par.begin(),s_son_par.end(),',');
        std::string::iterator iter_s_father = find(s_father_par.begin(),s_father_par.end(),',');
 
        // First parameter
        tmp_son_par.push_back(s_son_par.substr(0,(iter_s_son-s_son_par.begin())));
        tmp_father_par.push_back(s_father_par.substr(0,(iter_s_father-s_father_par.begin())));
 
        if (param_count > 2)
        {
           // All parameters exept first and last
           for (int i = 1; i < param_count-1; ++i)
           {
               iter_s_son = find(iter_s_son,s_son_par.end(),',');
               iter_s_father = find(iter_s_father,s_father_par.end(),',');
               tmp_son_par.push_back(s_son_par.substr(iter_s_son-s_son_par.begin(),
                                                 (find(iter_s_son,s_son_par.end(),',')-iter_s_son)-1));
               tmp_father_par.push_back(s_father_par.substr(iter_s_father-s_father_par.begin(),
                                                 (find(iter_s_father,s_father_par.end(),',')-iter_s_father)-1));
           }
 
           // Last parameter
           tmp_son_par.push_back(s_son_par.substr(iter_s_son-s_son_par.begin(),
                                                  iter_s_son-s_son_par.end()));
           tmp_father_par.push_back(s_father_par.substr(iter_s_father-s_father_par.begin(),
                                                        iter_s_father-s_father_par.end()));
        }
        if (param_count == 2)
        {
           // Second parameter
           tmp_son_par.push_back(s_son_par.substr(iter_s_son-s_son_par.begin(),
                                                  iter_s_son-s_son_par.end()));
 
           tmp_father_par.push_back(s_father_par.substr(iter_s_father-s_father_par.begin(),
                                                        iter_s_father-s_father_par.end()));
        }
 
        // Finally replace parameters from son
        // to father expression
        unsigned int pos   = 0;
        unsigned int l = s_father_expr.size();
        for (int i = 0; i < param_count;++i)
        {
            for (pos = 0;pos <s_father_expr.size();)
            {
                // There is a mistake in algorithm.
                // Last parameter isnt getting swapped.
                pos = s_father_expr.find(tmp_father_par.at(i));
                if (pos>l)break;
                s_father_expr.replace(pos,tmp_father_par.at(i).size(),tmp_son_par.at(i));
 
            std::cout<<"DEBUG "<<s_father_expr<<std::endl;
            }
        }
        // Using now useless pos
        pos = s_father_expr.find_first_of('{',0);
        resulting_expr = s_father_expr.substr(pos+1,s_father_expr.size()-pos-2);
    }
    std::cout<<"DEBUG "<<resulting_expr<<std::endl;
    return resulting_expr;
}

Входной файл:
program.clc
a=10.6
b=2
@f(c,d){c*b}
#$f(a,b)
 
Текущее время: 17:56. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru