
|
Parser Class Reference#include <Parser.h>
Collaboration diagram for Parser:
[legend]List of all members.
Detailed Description
Definition at line 3 of file Parser.h.
Constructor & Destructor Documentation
|
Definition at line 41 of file Parser.cpp.
References m_obuf, m_program_cwd, m_programname, m_run_program, and m_the_str. 00042 :m_pclParserIO(NULL)
00043 ,m_fil(NULL)
00044 ,m_linebase(NULL)
00045 ,m_current_line(NULL)
00046 ,m_next_line(NULL)
00047 ,m_onerror(NULL)
00048 ,m_nextbase(NULL)
00049 ,m_database(NULL)
00050 ,m_current_data(NULL)
00051 ,m_subbase(NULL)
00052 ,m_funcbase(NULL)
00053 ,m_placeholder(NULL)
00054 ,m_running(0)
00055 ,m_the_ptr(0)
00056 ,m_file_read(0)
00057 ,m_file_write(0)
00058 ,m_tab_pos(0)
00059 ,m_dataptr(0)
00060 ,m_variablebase(NULL)
00061 ,m_openbase(NULL)
00062 ,m_obufptr(0)
00063 ,m_load_ok(1)
00064 {
00065 *m_run_program = 0;
00066 *m_the_str = 0;
00067 *m_programname = 0;
00068 *m_program_cwd = 0;
00069 *m_obuf = 0;
00070 }
|
Parser::Parser |
( |
char * |
program |
) |
|
|
Member Function Documentation
void Parser::addlist |
( |
void * |
, |
|
|
void * |
|
|
) |
|
|
void Parser::cmd |
( |
char * |
s |
) |
|
|
|
Definition at line 1133 of file Parser.cpp.
References c(), editcmd(), execute(), finish(), flush_obuf(), inputstring(), ln, m_current_data, m_current_line, m_database, m_dataptr, m_fil, m_linebase, m_load_ok, m_onerror, m_pclParserIO, m_programname, m_run_program, m_running, m_the_ptr, m_the_str, next, pprintf(), read_file(), strupr(), the_str, verify_filename(), write_file(), and yyparse().
Referenced by main(), and text_output(). 01134 {
01135 struct stat st;
01136 FILE *fil;
01137 LINE *ln;
01138 LINE *ln2;
01139 LINE *newln;
01140 char *cmd;
01141 char *arg;
01142 char *option;
01143 char *ptr;
01144 int cmnum;
01145 int i;
01146 int x = 0;
01147 int quit;
01148 int dir;
01149 char c;
01150 char slask[512];
01151 char s[1024];
01152 char s2[1024];
01153 char tok[20];
01154 char repl[200];
01155 char with[200];
01156
01157 strcpy(s, in);
01158
01159 while (s[strlen(s) - 1] == 13 || s[strlen(s) - 1] == 10)
01160 s[strlen(s) - 1] = 0;
01161
01162 cmd = strtok(s," ");
01163 if (!cmd)
01164 {
01165 #ifdef DEBUG
01166 fprintf(stderr," * Empty CHR$(4)\n");
01167 #endif
01168 return;
01169 }
01170 arg = strtok(NULL,",");
01171 #ifdef DEBUG
01172 fprintf(stderr," * file command '%s' argument '%s'\n",cmd,arg);
01173 #endif
01174 if (!strcasecmp(cmd,"LOAD"))
01175 cmnum = 1;
01176 else
01177 if (!strcasecmp(cmd,"SAVE"))
01178 cmnum = 2;
01179 else
01180 if (!strcasecmp(cmd,"RUN"))
01181 cmnum = 3;
01182 else
01183 if (!strcasecmp(cmd,"LIST"))
01184 cmnum = 4;
01185 else
01186 if (!strcasecmp(cmd,"NEW"))
01187 cmnum = 5;
01188 else
01189 if (!strncasecmp(cmd,"cat",3))
01190 cmnum = 6;
01191 else
01192 if (!strcasecmp(cmd,"edit"))
01193 cmnum = 7;
01194 else
01195 if (!strcasecmp(cmd,"info"))
01196 cmnum = 8;
01197 else
01198 if (!strcasecmp(cmd,"help"))
01199 cmnum = 9;
01200 else
01201 if (!strcasecmp(cmd,"disks"))
01202 cmnum = 10;
01203 else
01204 if (!strcasecmp(cmd,"cd"))
01205 cmnum = 11;
01206 else
01207 if (!strcasecmp(cmd,"type"))
01208 cmnum = 12;
01209 else
01210 if (!strcasecmp(cmd,"dump"))
01211 cmnum = 13;
01212 else
01213 {
01214
01215 fprintf(stderr,"#### implement dos command\n");
01216 fprintf(stderr,"#### cmd '%s' arg '%s'\n",cmd,arg);
01217 cmnum = 0;
01218 }
01219
01220 option = strtok(NULL,",");
01221 while (option)
01222 {
01223 switch (*option)
01224 {
01225 default:
01226 fprintf(stderr,"#### cmd '%s' arg '%s' option '%s'\n",cmd,arg,option);
01227
01228 }
01229 option = strtok(NULL,",");
01230 }
01231
01232 switch (cmnum)
01233 {
01234 case 1:
01235 if (!arg)
01236 {
01237 pprintf("LOAD what?\n");
01238 break;
01239 }
01240 finish();
01241 m_running = 0;
01242 read_file( arg );
01243 if (!m_load_ok)
01244 {
01245 strupr( arg );
01246 finish();
01247 m_running = 0;
01248 read_file( arg );
01249 }
01250 if (!m_load_ok)
01251 {
01252 finish();
01253 }
01254 break;
01255 case 2:
01256 if (arg)
01257 {
01258 strupr( arg );
01259 strcpy(m_programname, arg);
01260 verify_filename(m_programname);
01261 }
01262 if (*m_programname >= 'A' && *m_programname <= 'Z' && m_load_ok)
01263 {
01264 write_file();
01265 }
01266 break;
01267 case 3:
01268 if (arg)
01269 {
01270 finish();
01271 m_running = 0;
01272 read_file( arg );
01273 if (!m_load_ok)
01274 {
01275 finish();
01276 m_running = 0;
01277 strupr( arg );
01278 read_file( arg );
01279 }
01280 }
01281 if (!m_load_ok)
01282 {
01283 finish();
01284 }
01285 do
01286 {
01287
01288
01289
01290 m_current_data = m_database;
01291 m_dataptr = 0;
01292 m_onerror = NULL;
01293 m_fil = NULL;
01294
01295 *m_run_program = 0;
01296
01297 m_running = 1;
01298
01299 this -> execute();
01300 this -> flush_obuf();
01301
01302
01303
01304 if (*m_run_program)
01305 {
01306 this -> finish();
01307 m_running = 0;
01308 read_file( m_run_program );
01309 }
01310
01311 } while (*m_run_program);
01312 break;
01313 case 4:
01314 m_running = 0;
01315 i = 0;
01316 for (ln = m_linebase; ln; ln = ln -> next)
01317 {
01318 m_current_line = ln;
01319
01320 if (ln -> line > -1)
01321 pprintf(" %5d",ln -> line);
01322 else
01323 pprintf(" ");
01324 pprintf(" %s\n",ln -> the_str);
01325
01326 strcpy(m_the_str,ln -> the_str);
01327 m_the_ptr = 0;
01328 if (yyparse( this ))
01329 {
01330 break;
01331 }
01332 if (m_pclParserIO -> m_more && i++ > 20 && ln -> next)
01333 {
01334 pprintf("[More]");
01335 inputstring(slask,200);
01336 if (*slask == 'q' || *slask == 'Q')
01337 break;
01338 i = 0;
01339 }
01340 }
01341 break;
01342 case 5:
01343 finish();
01344 break;
01345 case 6:
01346 if ((fil = popen("ls","r")) != NULL)
01347 {
01348 fgets(slask,200,fil);
01349 *s2 = 0;
01350 while (!feof(fil))
01351 {
01352 slask[strlen(slask) - 1] = 0;
01353 x = 0;
01354 for (i = 0; i < (int)strlen(slask); i++)
01355 if (slask[i] >= 'a' && slask[i] <= 'z')
01356 x++;
01357 if (!strcmp(slask,s2))
01358 x++;
01359 if (!x)
01360 {
01361 stat(slask, &st);
01362 i = 0;
01363 if (st.st_mode & 0100)
01364 i |= 1;
01365 if (st.st_mode & 010)
01366 i |= 2;
01367 if (st.st_mode & 01)
01368 i |= 4;
01369
01370 pprintf(" %c ","TIABSRAB"[i]);
01371 pprintf("%4d ",st.st_size / 1024);
01372 pprintf("%s\n",slask);
01373 }
01374 strcpy(s2,slask);
01375 fgets(slask,200,fil);
01376 }
01377 pclose(fil);
01378 }
01379 break;
01380 case 7:
01381 if (!arg)
01382 {
01383 ln = m_linebase;
01384 }
01385 else
01386 {
01387 i = atoi(arg);
01388 for (ln = m_linebase; ln; ln = ln -> next)
01389 if (ln -> line == i)
01390 break;
01391 if (!ln)
01392 {
01393 pprintf("Line %d does not exist\n",i);
01394 break;
01395 }
01396 }
01397 quit = 0;
01398 dir = 1;
01399 while (!quit)
01400 {
01401 if (!ln)
01402 pprintf("***** End of file.\n");
01403 else
01404 {
01405 if (ln -> line > -1)
01406 pprintf("%5d %s\n",ln -> line,ln -> the_str);
01407 else
01408 pprintf(" %s\n",ln -> the_str);
01409 }
01410
01411 pprintf("ED> ");
01412 inputstring(slask, 200);
01413 switch (*slask)
01414 {
01415 case '<':
01416 dir = -1;
01417 if (ln == m_linebase)
01418 pprintf("Already at top.\n");
01419 else
01420 {
01421 for (ln2 = m_linebase; ln2; ln2 = ln2 -> next)
01422 if (ln2 -> next == ln)
01423 break;
01424 ln = ln2;
01425 }
01426 break;
01427 case '>':
01428 dir = 1;
01429 if (!ln)
01430 pprintf("Already at bottom.\n");
01431 else
01432 ln = ln -> next;
01433 break;
01434 case 's':
01435 case 'S':
01436 if (!ln)
01437 break;
01438 sprintf(tok,"%c",slask[1]);
01439
01440 ptr = strtok(slask + 2,tok);
01441 if (!ptr)
01442 break;
01443 strcpy(repl, ptr);
01444
01445 ptr = strtok(NULL,tok);
01446 if (!ptr)
01447 break;
01448 strcpy(with, ptr);
01449
01450 strcpy(s2, ln -> the_str);
01451 ptr = strstr(s2, repl);
01452 if (!ptr)
01453 {
01454 pprintf("'%s' not found in line\n",repl);
01455 break;
01456 }
01457 *ptr = 0;
01458 {
01459 char temp[1024];
01460 sprintf(temp,"%s%s%s",
01461 s2,
01462 with,
01463 ptr + strlen(repl));
01464 if (strlen(temp) > strlen(ln -> the_str))
01465 {
01466 delete ln -> the_str;
01467 ln -> the_str = new char[strlen(temp) + 1];
01468 }
01469 strcpy(ln -> the_str,temp);
01470 }
01471 break;
01472 case 'd':
01473 case 'D':
01474 if (!ln)
01475 break;
01476 if (ln -> next -> line == -1)
01477 ln -> next -> line = ln -> line;
01478 if (ln == m_linebase)
01479 {
01480 m_linebase = ln -> next;
01481 delete ln -> the_str;
01482 delete ln;
01483 ln = m_linebase;
01484 }
01485 else
01486 {
01487 for (ln2 = m_linebase; ln2; ln2 = ln2 -> next)
01488 if (ln2 -> next == ln)
01489 break;
01490 if (ln2)
01491 {
01492 ln2 -> next = ln -> next;
01493 delete ln -> the_str;
01494 delete ln;
01495 ln = ln2 -> next;
01496 }
01497 }
01498 break;
01499 case 'i':
01500 case 'I':
01501 if (ln == m_linebase)
01502 ln2 = NULL;
01503 else
01504 for (ln2 = m_linebase; ln2; ln2 = ln2 -> next)
01505 if (ln2 -> next == ln)
01506 break;
01507 while (1)
01508 {
01509 pprintf(" .");
01510 inputstring(slask,500);
01511 if (!*slask)
01512 break;
01513 else
01514 {
01515 strupr(slask);
01516 i = 0;
01517 if (isdigit(*slask))
01518 {
01519 while (isdigit(slask[i]))
01520 i++;
01521 strncpy(s2,slask,i);
01522 s2[i] = 0;
01523 while (slask[i] == ' ' || slask[i] == 9)
01524 i++;
01525 }
01526 else
01527 *s2 = 0;
01528 newln = new LINE;
01529 newln -> next = ln;
01530 if (*s2)
01531 newln -> line = atoi(s2);
01532 else
01533 {
01534 newln -> line = ln ? ln -> line : -1;
01535 if (ln)
01536 ln -> line = -1;
01537 }
01538 newln -> the_str = new char[strlen(slask + i) + 1];
01539 strcpy(newln -> the_str,slask + i);
01540 if (ln2)
01541 ln2 -> next = newln;
01542 else
01543 m_linebase = newln;
01544 ln2 = newln;
01545 }
01546 }
01547 break;
01548 case '.':
01549 case 'q':
01550 case 'Q':
01551 quit++;
01552 break;
01553
01554 default:
01555 if (*slask)
01556 {
01557 pprintf("Edit Help\n");
01558 pprintf(" i insert line before current line\n");
01559 pprintf(" d delete current line\n");
01560 pprintf(" < move up\n");
01561 pprintf(" > move down\n");
01562 pprintf("[enter] move\n");
01563 pprintf(" s/x/y substitute x with y\n");
01564 pprintf(" . or Q exits\n");
01565 }
01566 else
01567 {
01568 if (dir < 0)
01569 {
01570 if (ln == m_linebase)
01571 pprintf("Already at top.\n");
01572 else
01573 {
01574 for (ln2 = m_linebase; ln2; ln2 = ln2 -> next)
01575 if (ln2 -> next == ln)
01576 break;
01577 ln = ln2;
01578 }
01579 }
01580 else
01581 if (dir > 0)
01582 {
01583 if (!ln)
01584 pprintf("Already at bottom.\n");
01585 else
01586 ln = ln -> next;
01587 }
01588 }
01589 break;
01590 }
01591 }
01592 break;
01593 case 8:
01594 getcwd(slask,200);
01595 ptr = strtok(slask,"/");
01596 *s2 = 0;
01597 while (ptr)
01598 {
01599 strcpy(s2,ptr);
01600 ptr = strtok(NULL,"/");
01601 }
01602 pprintf("Current disk: '%s'\n",s2);
01603 pprintf("Program name: '%s'\n",m_programname);
01604 break;
01605 case 9:
01606 pprintf("Online help:\n");
01607 pprintf(" LOAD <program>\n");
01608 pprintf(" SAVE [<program>]\n");
01609 pprintf(" RUN [<program>]\n");
01610 pprintf(" LIST - list loaded program\n");
01611 pprintf(" EDIT [<line>]\n");
01612 pprintf(" NEW - delete program in memory\n");
01613 pprintf(" TYPE <file> - read a file\n");
01614 pprintf(" DUMP <file> - hex dump a file\n");
01615 pprintf(" CATALOG - lists files on current disk\n");
01616 pprintf(" DISKS - show available disks\n");
01617 pprintf(" CD <disk> - change disk\n");
01618 pprintf(" INFO - show current disk and loaded program\n");
01619 pprintf(" HELP\n");
01620 pprintf(" QUIT\n");
01621 pprintf("\n");
01622 break;
01623 case 10:
01624 if ((fil = popen("ls -F ..","r")) != NULL)
01625 {
01626 fgets(slask,200,fil);
01627 while (!feof(fil))
01628 {
01629 slask[strlen(slask) - 1] = 0;
01630 if (slask[strlen(slask) - 1] == '/')
01631 {
01632 slask[strlen(slask) - 1] = 0;
01633 pprintf("%s\n",slask);
01634 }
01635 fgets(slask,200,fil);
01636 }
01637 pclose(fil);
01638 }
01639 break;
01640 case 11:
01641 if (!arg)
01642 {
01643 pprintf("CD where?\n");
01644 break;
01645 }
01646 ptr = strstr(arg,"..");
01647 if (ptr)
01648 *ptr = 0;
01649 ptr = strstr(arg,"/");
01650 if (ptr)
01651 *ptr = 0;
01652 sprintf(slask,"../%s",arg);
01653 if (chdir(slask) == -1)
01654 pprintf("Failed.\n");
01655 else
01656 pprintf("Ok.\n");
01657 break;
01658 case 12:
01659 if (!arg)
01660 {
01661 pprintf("TYPE what?\n");
01662 break;
01663 }
01664 verify_filename( arg );
01665 fil = fopen(arg,"rb");
01666 if (!fil)
01667 {
01668 strupr(arg);
01669 fil = fopen(arg,"rb");
01670 }
01671 if (fil)
01672 {
01673 fread(&c,1,1,fil);
01674 i = 0;
01675 while (!feof(fil))
01676 {
01677 c &= 127;
01678 if (c == 0x0d)
01679 {
01680 pprintf("\n");
01681 x++;
01682 } else
01683 {
01684 pprintf("%c",isprint(c) ? c : '.');
01685 x = 0;
01686 }
01687 fread(&c,1,1,fil);
01688 if (x)
01689 {
01690 if (m_pclParserIO -> m_more && i++ > 20 && !feof(fil))
01691 {
01692 pprintf("[More]");
01693 inputstring(slask,200);
01694 if (*slask == 'q' || *slask == 'Q')
01695 break;
01696 i = 0;
01697 }
01698 }
01699 }
01700 fclose(fil);
01701 if (!x)
01702 pprintf("\n");
01703 }
01704 else
01705 pprintf("Couldn't open '%s'...\n",arg);
01706 break;
01707 case 13:
01708 if (!arg)
01709 {
01710 pprintf("DUMP what?\n");
01711 break;
01712 }
01713 verify_filename( arg );
01714 fil = fopen(arg,"rb");
01715 if (!fil)
01716 {
01717 strupr(arg);
01718 fil = fopen(arg,"rb");
01719 }
01720 if (fil)
01721 {
01722 long addr = 0;
01723
01724 x = 0;
01725 while (!feof(fil))
01726 {
01727 pprintf("%04lx %04lx ",addr / 65536L,addr % 65536L);
01728 *slask = 0;
01729 for (i = 0; i < 16; i++)
01730 {
01731 fread(&c,1,1,fil);
01732 pprintf(" %02x", (unsigned char)c);
01733 if (isprint(c & 0x7f))
01734 sprintf(slask + strlen(slask),"%c",c & 0x7f);
01735 else
01736 strcat(slask,".");
01737 if (i == 7)
01738 {
01739 pprintf(" ");
01740 strcat(slask," ");
01741 }
01742 }
01743 pprintf(" %s\n",slask);
01744 if (m_pclParserIO -> m_more && x++ > 20 && !feof(fil))
01745 {
01746 pprintf("[More]");
01747 inputstring(slask,200);
01748 if (*slask == 'q' || *slask == 'Q')
01749 break;
01750 x = 0;
01751 }
01752 addr += 16;
01753 }
01754 fclose(fil);
01755 }
01756 else
01757 pprintf("Couldn't open '%s'...\n",arg);
01758 break;
01759
01760 default:
01761 if (!this -> editcmd( in ))
01762 {
01763 strcpy(m_the_str, in);
01764 m_the_ptr = 0;
01765 strupr(m_the_str);
01766 m_current_line = m_linebase;
01767 m_running = 1;
01768 if (yyparse( this ))
01769 fprintf(stderr," *** error\n");
01770 }
01771 break;
01772 }
01773 flush_obuf();
01774 }
|
int Parser::editcmd |
( |
char * |
s |
) |
|
|
|
Definition at line 1776 of file Parser.cpp.
References ln, and m_current_line.
Referenced by cmd(). 01777 {
01778 LINE *ln = m_current_line;
01779
01780 return 0;
01781
01782 if (*in >= 'a' && *in <= 'z')
01783 *in -= 32;
01784 if (isdigit(*in))
01785 {
01786
01787
01788
01789 }
01790 else
01791 switch (*in)
01792 {
01793 case 'E':
01794 break;
01795 case 'N':
01796 break;
01797 case 'I':
01798 break;
01799 case 'D':
01800 break;
01801
01802
01803
01804
01805
01806 case 'S':
01807 break;
01808 case '+':
01809 break;
01810 case '-':
01811 break;
01812 case 'L':
01813
01814 break;
01815
01816
01817
01818
01819 case 'A':
01820 break;
01821
01822 default:
01823 return 0;
01824 }
01825 return 1;
01826 }
|
void Parser::execute |
( |
void |
|
) |
|
|
void Parser::file_input |
( |
char * |
s, |
|
|
int |
l |
|
) |
|
|
|
Definition at line 837 of file Parser.cpp.
References c(), and m_fil. 00838 {
00839 int i = 0;
00840 short q = 0;
00841 unsigned char c;
00842
00843 if (m_fil)
00844 fread(&c,1,1,m_fil);
00845 while (m_fil && !feof(m_fil) && c != 0x8d && (q || (c & 0x7f) != ',') && c)
00846 {
00847 if (i >= l - 1)
00848 {
00849 fprintf(stderr," ********* BUFFER OVERFLOW ********\n");
00850 s[l - 1] = 0;
00851 fprintf(stderr,"%s\n",s);
00852 exit(-1);
00853 }
00854 s[i++] = c & 0x7f;
00855 if ( (c & 0x7f) == 34)
00856 q = !q;
00857 #ifdef DEBUG
00858 fprintf(stderr,"%c",c & 0x7f);
00859 #endif
00860 fread(&c,1,1,m_fil);
00861 }
00862 s[i] = 0;
00863 if (*s == 34 && s[strlen(s) - 1] == 34)
00864 {
00865 memmove(s,s + 1,strlen(s) + 1);
00866 s[strlen(s) - 1] = 0;
00867 }
00868 #ifdef DEBUG
00869 fprintf(stderr,"\n");
00870 #endif
00871 }
|
void Parser::finish |
( |
void |
|
) |
|
|
|
Definition at line 1065 of file Parser.cpp.
References ln, m_current_line, m_database, m_funcbase, m_linebase, m_load_ok, m_nextbase, m_openbase, m_programname, m_subbase, m_variablebase, next, and the_str.
Referenced by cmd(), and ~Parser().
|
void Parser::flush_obuf |
( |
|
) |
|
|
void Parser::get_data |
( |
char * |
s |
) |
|
|
VARIABLE * Parser::get_variable |
( |
char * |
name |
) |
|
|
int Parser::inputstring |
( |
char * |
, |
|
|
int |
|
|
) |
|
|
|
Definition at line 931 of file Parser.cpp.
References flush_obuf(), and m_pclParserIO.
Referenced by cmd(). 00932 {
00933 int ll = l;
00934 int i;
00935
00936 if (m_pclParserIO)
00937 {
00938 flush_obuf();
00939 if (m_pclParserIO -> read_text(s,&ll) == -1)
00940 {
00941 perror("read_text() failed");
00942 return -1;
00943 }
00944 s[ll] = 0;
00945 }
00946 else
00947 {
00948 fprintf(stderr,"#### USE PARSER IO FUNCTION ####\n");
00949 exit(-1);
00950
00951
00952 ll = read(0, s, l);
00953 s[ll] = 0;
00954 while (strlen(s) && (s[strlen(s) - 1] == 13 || s[strlen(s) - 1] == 10))
00955 {
00956 s[strlen(s) - 1] = 0;
00957 }
00958 if (*s == '.')
00959 {
00960 if (chdir( s ) == -1)
00961 {
00962 perror("chdir() failed");
00963 fprintf(stderr," ('%s') length %d\n",s,strlen(s));
00964 }
00965 }
00966 for (i = 0; i < ll; i++)
00967 if (s[i] >= 'a' && s[i] <= 'z')
00968 s[i] -= 32;
00969 }
00970 return ll;
00971 }
|
void Parser::load_variables |
( |
|
) |
|
|
|
Definition at line 990 of file Parser.cpp.
References addlist(), m_programname, and m_variablebase. 00991 {
00992 FILE *fil;
00993 VARIABLE *v;
00994 char slask[200];
00995
00996 sprintf(slask,"%s.lastrun",m_programname);
00997 if ((fil = fopen(slask,"rb")) != NULL)
00998 {
00999 v = new VARIABLE;
01000 fread(v,1,sizeof(VARIABLE),fil);
01001 while (!feof(fil))
01002 {
01003 addlist(&m_variablebase,v);
01004
01005 v = new VARIABLE;
01006 fread(v,1,sizeof(VARIABLE),fil);
01007 }
01008 delete v;
01009 fclose(fil);
01010 }
01011 }
|
|
Definition at line 1023 of file Parser.cpp. 01024 {
01025 switch (addr)
01026 {
01027 default:
01028 return 0;
01029 }
01030 }
|
void Parser::poke |
( |
int |
, |
|
|
int |
|
|
) |
|
|
|
Definition at line 1032 of file Parser.cpp. 01033 {
01034 int addr = a;
01035
01036 if (addr < 0)
01037 addr += 65536;
01038
01039 #ifdef DEBUGMEM
01040 fprintf(stderr,"poke(%d,%d)\n",addr,value);
01041 #endif
01042 }
|
void Parser::pprintf |
( |
char * |
format, |
|
|
|
... |
|
) |
|
|
|
Definition at line 824 of file Parser.cpp.
References text_output().
Referenced by cmd(). 00825 {
00826 va_list vl;
00827 char buf[1024];
00828
00829 va_start(vl, format);
00830 vsprintf(buf, format, vl);
00831 va_end(vl);
00832
00833 text_output( buf );
00834 }
|
void Parser::read_data |
( |
VARLIST * |
vl |
) |
|
|
|
Definition at line 902 of file Parser.cpp.
References get_data(), value, and var. 00903 {
00904 int i;
00905
00906 for (i = 0; i < vl -> qty; i++)
00907 {
00908 get_data(vl -> var[i] -> svalue);
00909 vl -> var[i] -> value = atof(vl -> var[i] -> svalue);
00910 #ifdef DEBUGDATA
00911 fprintf(stderr,"Read Data; %s = '%s'\n",vl -> var[i] -> name,vl -> var[i] -> svalue);
00912 #endif
00913 }
00914 }
|
void Parser::read_file |
( |
char * |
|
) |
|
|
|
Definition at line 156 of file Parser.cpp.
References addlist(), applesoft_tokens, c(), ln, m_current_line, m_linebase, m_load_ok, m_next_line, m_program_cwd, m_programname, m_the_ptr, m_the_str, strupr(), the_str, verify_filename(), write_file(), and yyparse().
Referenced by cmd(). 00157 {
00158 FILE *fil;
00159 LINE *ln;
00160 int i,x;
00161 short size;
00162 short q;
00163 short ifc;
00164 short data;
00165 short rem;
00166 short ok = 1;
00167 short uc = 0;
00168 unsigned char c_length;
00169 unsigned char c_eight;
00170 unsigned char c_line1;
00171 unsigned char c_line2;
00172 unsigned char c;
00173 char slask[1024];
00174 char filename_uc[100];
00175
00176 if (!strcasecmp(filename,"basefix"))
00177 return;
00178
00179 verify_filename( filename );
00180 strcpy(filename_uc, filename);
00181 strupr(filename_uc);
00182 m_load_ok = 0;
00183
00184 if (*filename_uc < 'A' || *filename_uc > 'Z')
00185 {
00186 fprintf(stderr,"Illegal filename '%s'\n",filename);
00187 return;
00188 }
00189
00190 strcpy(m_programname,filename);
00191 getcwd(m_program_cwd,200);
00192 fprintf(stderr,"*** Current program: '%s' ***\n",m_programname);
00193 fprintf(stderr,"getcwd() == '%s'\n",m_program_cwd);
00194
00195 sprintf(slask,"%s.txt",filename);
00196 fil = fopen(slask,"rt");
00197 if (!fil)
00198 {
00199 sprintf(slask,"%s.txt",filename_uc);
00200 fil = fopen(slask,"rt");
00201 if (fil)
00202 uc++;
00203 }
00204 if (!fil)
00205 {
00206 sprintf(slask,"../ea.master/%s.txt",filename);
00207 fil = fopen(slask,"rt");
00208 if (!fil)
00209 {
00210 sprintf(slask,"../ea.master/%s.txt",filename_uc);
00211 fil = fopen(slask,"rt");
00212 if (fil)
00213 uc++;
00214 }
00215 if (fil)
00216 {
00217 fclose(fil);
00218 chdir("../ea.master");
00219 sprintf(slask,"%s.txt",filename);
00220 fil = fopen(slask,"rt");
00221 if (!fil)
00222 {
00223 sprintf(slask,"%s.txt",filename_uc);
00224 fil = fopen(slask,"rt");
00225 if (fil)
00226 uc++;
00227 }
00228 }
00229 }
00230 if (uc)
00231 strcpy(m_programname,filename_uc);
00232 if (fil)
00233 {
00234 fprintf(stderr," ** loading text file '%s'\n",slask);
00235 fgets(slask,1024,fil);
00236 while (!feof(fil))
00237 {
00238 slask[strlen(slask) - 1] = 0;
00239 i = 0;
00240 while (slask[i] && (slask[i] == ' ' || slask[i] == 9))
00241 i++;
00242
00243 ln = new LINE;
00244 if (isdigit(slask[i]))
00245 {
00246 x = i;
00247 while (isdigit(slask[i]))
00248 i++;
00249 slask[i++] = 0;
00250 ln -> line = atoi(slask + x);
00251 while (slask[i] && (slask[i] == ' ' || slask[i] == 9))
00252 i++;
00253 }
00254 else
00255 {
00256 ln -> line = -1;
00257 }
00258 ln -> the_str = new char[strlen(slask + i) + 1];
00259 strcpy(ln -> the_str,slask + i);
00260 addlist(&m_linebase,ln);
00261
00262 if (!strncasecmp(ln -> the_str,"data ",5))
00263 {
00264 strcpy(m_the_str,ln -> the_str);
00265 m_the_ptr = 0;
00266 m_current_line = ln;
00267 if (yyparse(this))
00268 {
00269 m_next_line = NULL;
00270 ok = 0;
00271 }
00272 }
00273
00274 fgets(slask,1024,fil);
00275 }
00276 fclose(fil);
00277 m_load_ok = ok;
00278 }
00279 else
00280 {
00281 fil = fopen(filename,"rb");
00282 if (!fil)
00283 {
00284 fil = fopen(filename_uc,"rb");
00285 if (fil)
00286 uc++;
00287 }
00288 if (!fil)
00289 {
00290 sprintf(slask,"../ea.master/%s",filename);
00291 fil = fopen(slask,"rb");
00292 if (!fil)
00293 {
00294 sprintf(slask,"../ea.master/%s",filename_uc);
00295 fil = fopen(slask,"rb");
00296 if (fil)
00297 uc++;
00298 }
00299 if (fil)
00300 {
00301 fclose(fil);
00302 chdir("../ea.master");
00303 fil = fopen(filename,"rb");
00304 if (!fil)
00305 {
00306 fil = fopen(filename_uc,"rb");
00307 if (fil)
00308 uc++;
00309 }
00310 }
00311 }
00312 if (uc)
00313 strcpy(m_programname,filename_uc);
00314 if (fil)
00315 {
00316 fprintf(stderr," ** loading binary file '%s'\n",m_programname);
00317
00318 fread(&size,1,2,fil);
00319 fprintf(stderr," size %d\n",size);
00320 while (!feof(fil))
00321 {
00322
00323 fread(&c_length,1,1,fil);
00324 fread(&c_eight,1,1,fil);
00325 if (!c_eight)
00326 {
00327 break;
00328 }
00329
00330 fread(&c_line1,1,1,fil);
00331 fread(&c_line2,1,1,fil);
00332 ln = new LINE;
00333 ln -> line = (((int)c_line2) << 8) + c_line1;
00334 *slask = 0;
00335 q = 0;
00336 ifc = 0;
00337 data = 0;
00338 rem = 0;
00339
00340
00341 fread(&c,1,1,fil);
00342 while (c && !feof(fil))
00343 {
00344 if (c >= 0x80)
00345 {
00346 if (c == 0x83)
00347 data = 1;
00348 if (c == 0xad)
00349 ifc = 1;
00350 if (c == 0xb2)
00351 rem = 1;
00352 if (ifc && *slask && (c == 0xc4 || c == 0xab))
00353 {
00354 ln -> the_str = new char[strlen(slask) + 1];
00355 strcpy(ln -> the_str,slask);
00356 if (*slask)
00357 {
00358 addlist(&m_linebase,ln);
00359 } else
00360 delete ln;
00361 if (data && *slask)
00362 {
00363 strcpy(m_the_str,slask);
00364 m_the_ptr = 0;
00365 m_current_line = ln;
00366 if (yyparse(this))
00367 {
00368 m_next_line = NULL;
00369 ok = 0;
00370 }
00371 }
00372
00373 ln = new LINE;
00374 ln -> line = -1;
00375 *slask = 0;
00376 q = 0;
00377 ifc = 0;
00378 data = 0;
00379 }
00380 if (strlen(slask) + strlen(applesoft_tokens[c - 0x80]) < 1023)
00381 sprintf(slask + strlen(slask)," %s ",applesoft_tokens[c - 0x80]);
00382 }
00383 else
00384 if (c == ':' && !q && !rem)
00385 {
00386 ln -> the_str = new char[strlen(slask) + 1];
00387 strcpy(ln -> the_str,slask);
00388 if (*slask)
00389 {
00390 addlist(&m_linebase,ln);
00391 } else
00392 delete ln;
00393 if (data && *slask)
00394 {
00395 strcpy(m_the_str,slask);
00396 m_the_ptr = 0;
00397 m_current_line = ln;
00398 if (yyparse(this))
00399 {
00400 m_next_line = NULL;
00401 ok = 0;
00402 }
00403 }
00404
00405 ln = new LINE;
00406 ln -> line = -1;
00407 *slask = 0;
00408 q = 0;
00409 ifc = 0;
00410 data = 0;
00411 }
00412 else
00413 {
00414 if (rem && (c == 13 || c == 10))
00415 c = '_';
00416 if (strlen(slask) + 1 < 1023)
00417 sprintf(slask + strlen(slask),"%c",c);
00418 if (c == 34)
00419 q = !q;
00420 }
00421
00422 fread(&c,1,1,fil);
00423 }
00424
00425 ln -> the_str = new char[strlen(slask) + 1];
00426 strcpy(ln -> the_str,slask);
00427 if (*slask)
00428 {
00429 addlist(&m_linebase,ln);
00430 } else
00431 delete ln;
00432 if (data && *slask)
00433 {
00434 strcpy(m_the_str,slask);
00435 m_the_ptr = 0;
00436 m_current_line = ln;
00437 if (yyparse(this))
00438 {
00439 m_next_line = NULL;
00440 ok = 0;
00441 }
00442 }
00443 }
00444 fclose(fil);
00445 m_load_ok = ok;
00446
00447 if (ok)
00448 write_file();
00449 }
00450 else
00451 {
00452 fprintf(stderr,"Couldn't open '%s'...\n",filename);
00453
00454 }
00455 }
00456 }
|
|
Definition at line 484 of file Parser.cpp.
References m_variablebase, next, and value. 00485 {
00486 VARIABLE *v;
00487 int i;
00488 char type[2];
00489
00490 if (*name != '$')
00491 {
00492 switch (name[strlen(name) - 1])
00493 {
00494 case '$':
00495 strcpy(type,"$");
00496 name[strlen(name) - 1] = 0;
00497 break;
00498 case '%':
00499 strcpy(type,"%");
00500 name[strlen(name) - 1] = 0;
00501 break;
00502 default:
00503 *type = 0;
00504 }
00505 name[2] = 0;
00506 strcat(name,type);
00507 }
00508
00509 if (p)
00510 {
00511 strcat(name,"(");
00512 for (i = 0; i < p -> qty; i++)
00513 {
00514 if (i)
00515 strcat(name,",");
00516 sprintf(name + strlen(name),"%d",(int)(p -> values[i] + 0.01));
00517 }
00518 strcat(name,")");
00519 }
00520
00521 for (v = m_variablebase; v; v = v -> next)
00522 {
00523 if (!strcmp(v -> name,name))
00524 break;
00525 }
00526 if (!v)
00527 {
00528 v = new VARIABLE;
00529 if (!v)
00530 {
00531 fprintf(stderr,"malloc failed\n");
00532 exit(-1);
00533 }
00534 strcpy(v -> name,name);
00535 v -> ivalue = 0;
00536 v -> value = v -> fnvalue = 0;
00537 *v -> svalue = 0;
00538 v -> next = m_variablebase;
00539 m_variablebase = v;
00540 }
00541 return v;
00542 }
|
void Parser::removelist |
( |
void * |
, |
|
|
void * |
|
|
) |
|
|
|
Definition at line 116 of file Parser.cpp.
References next.
Referenced by text_output(). 00117 {
00118 LINE **base = (LINE **)_base;
00119 LINE *item = (LINE *)_item;
00120 LINE *q,*prev = NULL;
00121
00122 if (item == *base)
00123 *base = item -> next;
00124 else
00125 {
00126 for (q = *base; q; q = q -> next)
00127 if (item == q)
00128 {
00129 prev -> next = item -> next;
00130 break;
00131 }
00132 else
00133 prev = q;
00134 }
00135 }
|
void Parser::save_variables |
( |
|
) |
|
|
|
Definition at line 973 of file Parser.cpp.
References m_program_cwd, m_programname, m_variablebase, and next. 00974 {
00975 FILE *fil;
00976 VARIABLE *v;
00977 char slask[200];
00978
00979 sprintf(slask,"%s/%s.lastrun",m_program_cwd,m_programname);
00980 if ((fil = fopen(slask,"wb")) != NULL)
00981 {
00982 for (v = m_variablebase; v; v = v -> next)
00983 {
00984 fwrite(v,1,sizeof(VARIABLE),fil);
00985 }
00986 fclose(fil);
00987 }
00988 }
|
void Parser::strupr |
( |
char * |
|
) |
|
|
|
Definition at line 88 of file Parser.cpp.
Referenced by cmd(), and read_file(). 00089 {
00090 int i;
00091
00092 for (i = 0; i < (int)strlen(s); i++)
00093 if (s[i] >= 'a' && s[i] <= 'z')
00094 s[i] -= 32;
00095 }
|
void Parser::text_output |
( |
char * |
s |
) |
|
|
|
Definition at line 545 of file Parser.cpp.
References addlist(), cmd(), flush_obuf(), m_fil, m_file_read, m_file_write, m_next_line, m_obuf, m_obufptr, m_onerror, m_openbase, m_pclParserIO, m_run_program, m_running, next, OBUFSIZE, removelist(), and verify_filename().
Referenced by pprintf(). 00546 {
00547 OPEN *o;
00548 char *cmd;
00549 char *arg;
00550 char *option;
00551 long offset;
00552 int i;
00553 short cmnum;
00554 short option_s;
00555 short option_d;
00556 short option_l;
00557 short option_r;
00558 char slask[1024];
00559
00560 if (*s == 4)
00561 {
00562 if (s[strlen(s) - 1] == '\n');
00563 s[strlen(s) - 1] = 0;
00564 m_file_read = 0;
00565 m_file_write = 0;
00566 m_fil = NULL;
00567 cmd = strtok(s + 1," ");
00568 if (!cmd)
00569 {
00570 #ifdef DEBUG
00571 fprintf(stderr," * Empty CHR$(4)\n");
00572 #endif
00573 return;
00574 }
00575 arg = strtok(NULL,",");
00576 #ifdef DEBUG
00577 fprintf(stderr," * file command '%s' argument '%s'\n",cmd,arg);
00578 #endif
00579 if (!strcmp(cmd,"RUN"))
00580 cmnum = 1;
00581 else
00582 if (!strcmp(cmd,"OPEN"))
00583 cmnum = 2;
00584 else
00585 if (!strcmp(cmd,"CLOSE"))
00586 cmnum = 3;
00587 else
00588 if (!strcmp(cmd,"READ"))
00589 cmnum = 4;
00590 else
00591 if (!strcmp(cmd,"WRITE"))
00592 cmnum = 5;
00593 else
00594 if (!strcmp(cmd,"DELETE"))
00595 cmnum = 6;
00596 else
00597 {
00598 fprintf(stderr,"##############################################\n");
00599 fprintf(stderr,"#### implement dos command\n");
00600 fprintf(stderr,"#### cmd '%s' arg '%s'\n",cmd,arg);
00601 cmnum = 0;
00602 }
00603
00604 option = strtok(NULL,",");
00605 option_s = -1;
00606 option_d = -1;
00607 option_l = -1;
00608 option_r = -1;
00609 while (option)
00610 {
00611 #ifdef DEBUG
00612 fprintf(stderr," option '%s'\n",option);
00613 #endif
00614 if (!cmnum)
00615 {
00616 fprintf(stderr,"#### cmd '%s' arg '%s' option '%s'\n",cmd,arg,option);
00617 }
00618 else
00619 switch (*option)
00620 {
00621 case 'S':
00622 option_s = atoi(option + 1);
00623 break;
00624 case 'D':
00625 option_d = atoi(option + 1);
00626 break;
00627 case 'L':
00628 option_l = atoi(option + 1);
00629 break;
00630 case 'R':
00631 option_r = atoi(option + 1);
00632 break;
00633 default:
00634 fprintf(stderr,"#### cmd '%s' arg '%s' option '%s'\n",cmd,arg,option);
00635 fprintf(stderr,"##############################################\n");
00636 }
00637 option = strtok(NULL,",");
00638 }
00639
00640 if (!cmnum)
00641 {
00642 fprintf(stderr,"##############################################\n");
00643 }
00644
00645 if (!m_running)
00646 return;
00647
00648 switch (cmnum)
00649 {
00650 case 1:
00651 verify_filename( arg );
00652 fprintf(stderr," * RUN '%s'\n",arg);
00653 strcpy(m_run_program,arg);
00654 m_next_line = NULL;
00655 break;
00656 case 2:
00657 verify_filename( arg );
00658 for (o = m_openbase; o; o = o -> next)
00659 if (!strcmp(o -> name,arg))
00660 break;
00661 if (o)
00662 {
00663
00664 }
00665 else
00666 {
00667 o = new OPEN;
00668 o -> fil = fopen(arg,"r+b");
00669 if (!o -> fil)
00670 o -> fil = fopen(arg,"w+b");
00671 if (!o -> fil)
00672 {
00673 fprintf(stderr," *** OPEN '%s' failed\n",arg);
00674 m_next_line = m_onerror;
00675 delete o;
00676 }
00677 else
00678 {
00679 strcpy(o -> name,arg);
00680 stat(arg,&o -> file_stat);
00681 o -> option_s = option_s;
00682 o -> option_d = option_d;
00683 o -> option_l = option_l;
00684 o -> option_r = 0;
00685 addlist(&m_openbase,o);
00686 }
00687 }
00688 break;
00689 case 3:
00690 if (arg)
00691 {
00692 verify_filename( arg );
00693 for (o = m_openbase; o; o = o -> next)
00694 if (!strcmp(o -> name,arg))
00695 break;
00696 if (!o)
00697 fprintf(stderr," *** FILE not OPEN (CLOSE)\n");
00698 else
00699 {
00700 fclose(o -> fil);
00701 removelist(&m_openbase,o);
00702 delete o;
00703 }
00704 }
00705 else
00706 {
00707 while (m_openbase)
00708 {
00709 o = m_openbase;
00710 fclose(o -> fil);
00711 removelist(&m_openbase,o);
00712 delete o;
00713 }
00714 }
00715 break;
00716 case 4:
00717 verify_filename( arg );
00718 for (o = m_openbase; o; o = o -> next)
00719 if (!strcmp(o -> name,arg))
00720 break;
00721 if (!o)
00722 fprintf(stderr," *** FILE not OPEN (READ)\n");
00723 else
00724 {
00725 if (option_r > -1)
00726 {
00727 o -> option_r = option_r;
00728 offset = (long)o -> option_l * (long)o -> option_r;
00729 if (offset > o -> file_stat.st_size)
00730 m_next_line = m_onerror;
00731
00732 if (fseek(o -> fil,offset,SEEK_SET))
00733 m_next_line = m_onerror;
00734 }
00735 m_file_read = 1;
00736 m_fil = o -> fil;
00737 }
00738 break;
00739 case 5:
00740 verify_filename( arg );
00741 for (o = m_openbase; o; o = o -> next)
00742 if (!strcmp(o -> name,arg))
00743 break;
00744 if (!o)
00745 fprintf(stderr," *** FILE not OPEN (WRITE)\n");
00746 else
00747 {
00748 #ifdef DEBUG
00749 fprintf(stderr," * Write to file '%s'\n",o -> name);
00750 #endif
00751 if (option_r > -1)
00752 {
00753 o -> option_r = option_r;
00754 offset = (long)o -> option_l * (long)o -> option_r;
00755 #ifdef DEBUG
00756 fprintf(stderr," * WRITE '%s' ,L%d ,R%d Offset 0x%04lx\n",arg,o -> option_l,o -> option_r,offset);
00757 #endif
00758 if (fseek(o -> fil,offset,SEEK_SET))
00759 m_next_line = m_onerror;
00760 }
00761 m_file_write = 1;
00762 m_fil = o -> fil;
00763 #ifdef DEBUG
00764 fprintf(stderr," * ...\n");
00765 #endif
00766 }
00767 break;
00768 case 6:
00769 verify_filename( arg );
00770 unlink(arg);
00771 break;
00772
00773 default:
00774 break;
00775 }
00776
00777 }
00778 else
00779 {
00780 if (m_fil && m_file_write)
00781 {
00782 if (s[strlen(s) - 1] == 0x0a)
00783 s[strlen(s) - 1] = 0x8d;
00784 fwrite(s,strlen(s),1,m_fil);
00785 }
00786 else
00787 if (m_pclParserIO)
00788 {
00789 int l = strlen(s);
00790
00791 if (m_obufptr + l >= OBUFSIZE - 1)
00792 {
00793 flush_obuf();
00794 }
00795 memmove(m_obuf + m_obufptr, s, l);
00796 m_obufptr += l;
00797 }
00798 else
00799 {
00800 fprintf(stderr,"#### USE PARSER IO FUNCTION ####\n");
00801 exit(-1);
00802
00803 i = 0;
00804 while (s[i])
00805 {
00806 if (strlen(s + i) > 40)
00807 {
00808 strncpy(slask,s + i,40);
00809 slask[40] = 0;
00810 printf("%s\n",slask);
00811 i += 40;
00812 }
00813 else
00814 {
00815 printf("%s",s + i);
00816 i += strlen(s + i);
00817 }
00818 fflush(stdout);
00819 }
00820 }
00821 }
00822 }
|
void Parser::verify_filename |
( |
char * |
s |
) |
|
|
|
Definition at line 138 of file Parser.cpp.
Referenced by cmd(), read_file(), and text_output(). 00139 {
00140 int i;
00141
00142 if (s)
00143 {
00144 for (i = 0; i < (int)strlen(s); i++)
00145 {
00146 switch (s[i])
00147 {
00148 case '/':
00149 s[i] = '_';
00150 }
00151 }
00152 }
00153 }
|
void Parser::write_file |
( |
|
) |
|
|
|
Definition at line 458 of file Parser.cpp.
References ln, m_linebase, m_load_ok, m_programname, next, and the_str.
Referenced by cmd(), and read_file(). 00459 {
00460 FILE *fil;
00461 LINE *ln;
00462 char slask[200];
00463
00464 if (!*m_programname)
00465 return;
00466
00467 if (!m_load_ok)
00468 return;
00469
00470 sprintf(slask,"%s.txt",m_programname);
00471 if ((fil = fopen(slask,"wt")) != NULL)
00472 {
00473 for (ln = m_linebase; ln; ln = ln -> next)
00474 {
00475 if (ln -> line > -1)
00476 fprintf(fil,"%5d %s\n",ln -> line,ln -> the_str);
00477 else
00478 fprintf(fil," %s\n",ln -> the_str);
00479 }
00480 fclose(fil);
00481 }
00482 }
|
Member Data Documentation
The documentation for this class was generated from the following files:
|