{"id":131,"date":"2018-09-07T20:54:32","date_gmt":"2018-09-08T04:54:32","guid":{"rendered":"https:\/\/www.viscerallogic.com\/programming\/blog\/?p=131"},"modified":"2018-09-07T20:56:21","modified_gmt":"2018-09-08T04:56:21","slug":"basic-interpreter-part-vi","status":"publish","type":"post","link":"https:\/\/www.viscerallogic.com\/programming\/blog\/basic-interpreter-part-vi\/","title":{"rendered":"BASIC Interpreter, Part VI"},"content":{"rendered":"

This is a continuation of Part V<\/a>. In the previous section, we added support for the GOTO<\/code> statement. Since we don’t yet have any control logic, that is not very useful, but it does lay the infrastructure for one of the features we will add this time: IF-THEN<\/code>. We will also add the READ<\/code> and DATA<\/code> statements.
\n<\/p>\n

Following the BASIC guide we are using, an IF-THEN<\/code> statement takes the following form: <LINE> IF <EXPRESSION> <RELATION> <EXPRESSION> THEN <LINE><\/code>. I.e., compare two expressions using some test operator, and if the result is true, jump to the specified line number; otherwise continue to the next line. We have already defined a token for the =<\/code> operator for use in the LET<\/code> statement, but we will need to add tokens for the remaining comparisons: <<\/code>, ><\/code>, <=<\/code>, >=<\/code>, and <><\/code>.<\/p>\n

Let’s start by creating a class to handle the IF-THEN<\/code> statement. IfThen<\/code> will be a subclass of Program<\/code>; it will store pointers to two DoubleExpression<\/code>s to be evaluated at run time, which comparison is to be performed, and the line number to jump to if the comparison is successful. There are various ways of indicating which operation is to be performed; in this case, I have chosen to store it as a C-style string; using an enum<\/code> would be another good option. Here is the header file, ifthen.h:<\/em><\/p>\n

#ifndef _IFTHEN_H_\r\n#define _IFTHEN_H_\r\n\r\n#include \"program.h\"\r\n#include \"doubleexpression.h\"\r\n\r\n\/*\r\nThis class provides support for the IF-THEN statement.\r\n*\/\r\nclass IfThen : public Program {\r\npublic:\r\n\tIfThen(DoubleExpression *a, DoubleExpression *b, char *op, int line);\r\n\t~IfThen();\r\n\t\r\n\tvoid execute() const;\t\t\t\/\/ run this line of the program\r\n\tvoid list(std::ostream& os) const;\t\/\/ list this line\r\n\r\nprivate:\r\n\tDoubleExpression *a, *b;\r\n\tchar *op;\r\n\tint line;\r\n};\r\n\r\n#endif<\/pre>\n
The implementation is pretty straightforward. The constructor stores all the member variables, the destructor deletes the DoubleExpression<\/code>s, execute()<\/code> performs the comparison operation and jumps to the appropriate line if it succeeds, and list()<\/code> prints out the statement (which is simplified since we stored the operator as a c-string). So here is ifthen.cpp:<\/em><\/p>\n
#include <cstring>\r\n\r\n#include \"ifthen.h\"\r\n#include \"basic.h\"\r\n\r\n\/\/ create a new statement instance\r\nIfThen::IfThen(DoubleExpression *a, DoubleExpression *b, char *op, int line){\r\n\tthis->a = a;\r\n\tthis->b = b;\r\n\tthis->op = op;\r\n\tthis->line = line;\r\n}\r\n\r\n\/\/ clean up the expression pointers\r\nIfThen::~IfThen(){\r\n\tdelete a;\r\n\tdelete b;\r\n}\r\n\r\n\/\/ run this line of the program\r\nvoid IfThen::execute() const{\r\n\tdouble aVal = a->value();\r\n\tdouble bVal = b->value();\r\n\tbool result = false;\r\n\t\r\n\tif( strcmp(op, \"=\") == 0 )\r\n\t\tresult = aVal == bVal;\r\n\telse if( strcmp(op, \"<\") == 0 )\r\n\t\tresult = aVal < bVal;\r\n\telse if( strcmp(op, \">\") == 0 )\r\n\t\tresult = aVal > bVal;\r\n\telse if( strcmp(op, \"<=\") == 0 )\r\n\t\tresult = aVal <= bVal;\r\n\telse if( strcmp(op, \">=\") == 0 )\r\n\t\tresult = aVal >= bVal;\r\n\telse if( strcmp(op, \"<>\") == 0 )\r\n\t\tresult = aVal != bVal;\r\n\t\r\n\tif( result )\r\n\t\tBasic::instance()->gotoLine(line);\r\n\telse\r\n\t\tProgram::execute();\r\n}\r\n\r\n\/\/ list this line\r\nvoid IfThen::list(std::ostream& os) const{\r\n\tos << \"IF \" << a->list() << ' ' << op << ' ';\r\n\tos << b->list() << \" THEN \" << line;\r\n}<\/pre>\n
Next, we need to add support in our Bison input file. First, make sure to include the new IfThen<\/code> header file:<\/p>\n
#include \"ifthen.h\"<\/pre>\n
We already have a EQUAL<\/code> token defined for the LET<\/code> assignment statement, and we will re-use it here since it is the same character. We need to add tokens for IF<\/code>, THEN<\/code>, and the remaining comparison operators:<\/p>\n
%token IF\r\n%token THEN\r\n%token LESS\r\n%token GREATER\r\n%token LESSEQUAL\r\n%token GREATEREQUAL\r\n%token NOTEQUAL<\/pre>\n
We somehow need to convert these tokens into C-strings to pass to the IfThen<\/code> class, so we will create a new non-terminal token comp<\/code> that will be an sVal<\/code> type to store the operator:<\/p>\n
%type <sVal> comp<\/pre>\n
Create the rule for our new comp<\/code> symbol:<\/p>\n
comp:\r\n\tEQUAL\t\t\t{ $$ = \"=\"; }\r\n\t| LESS\t\t\t{ $$ = \"<\"; }\r\n\t| GREATER\t\t{ $$ = \">\"; }\r\n\t| LESSEQUAL\t\t{ $$ = \"<=\"; }\r\n\t| GREATEREQUAL\t\t{ $$ = \">=\"; }\r\n\t| NOTEQUAL\t\t{ $$ = \"<>\"; }\r\n;<\/pre>\n
And now update the program<\/code> rule to recognize IF-THEN<\/code> statements:<\/p>\n
program:\r\n\tPRINT exprList\t\t\t{ $$ = new Print($2); }\r\n\t| LET VAR EQUAL doubleExpr\t{\r\n\t\t\t\t\t\t$$ = new Let($2, $4);\r\n\t\t\t\t\t\tfree($2);\t\/\/ malloced in basic.l\r\n\t\t\t\t\t}\r\n\t| GOTO INT\t\t\t{ $$ = new Goto($2); }\r\n\t| END\t\t\t\t{ $$ = new End(); }\r\n\t| IF doubleExpr comp doubleExpr THEN INT\r\n\t\t\t\t\t{ $$ = new IfThen($2, $4, $3, $6); }\r\n;<\/pre>\n
Now, on to the flex input file. Add scanners for the new tokens defined in the Bison input file:<\/p>\n
IF\t\t\t{ return IF; }\r\nTHEN\t\t\t{ return THEN; }\r\n\\<\t\t\t{ return LESS; }\r\n\\>\t\t\t{ return GREATER; }\r\n\\<\\=\t\t\t{ return LESSEQUAL; }\r\n\\>\\=\t\t\t{ return GREATEREQUAL; }\r\n\\<\\>\t\t\t{ return NOTEQUAL; }<\/pre>\n
Finally, add the new files in your Makefile. You can now run programs like this:<\/p>\n
Welcome to BASIC!\r\nEnter a program name: test\r\n>10 if 1 < 2 then 30\r\n>20 print \"1 > 2\"\r\n>30 if 1 = 1 then 50\r\n>40 print \"1 <> 1\"\r\n>50 if 2 > 1 then 70\r\n>60 print \"2 < 1\"\r\n>70 if 1 <= 2 then 90\r\n>80 print \"1 > 2\"\r\n>90 if 2 >= 1 then 110\r\n>100 print \"2 < 1\"\r\n>110 if 1 <> 2 then 130\r\n>120 print \"1 = 2\"\r\n>130 end\r\n>run\r\n><\/pre>\n
Adding support for READ<\/code> and DATA<\/code> will require some reworking of how we do things. Prior to the program running, all the DATA<\/code> statements must already be evaluated so their values can be stored and ready for any READ<\/code> statement. We will accomplish this by adding a pre-evaluation<\/em> loop before the main execution loop. But first, we will add storage for the DATA<\/code> values and functions to read\/write them. We will store the values in a std::deque<\/code>, which implements a first-in-first-out<\/em> queue.<\/p>\n
Start by including the header files for std::vector<\/code> and std::deque<\/code> in basic.h<\/em>:<\/p>\n
#include <map>\r\n#include <string>\r\n#include <iostream>\r\n#include <vector>\r\n#include <deque>\r\n\r\n#include \"program.h\"\r\n#include \"doubleexpression.h\"\r\n<\/pre>\n
Next, declare functions for the READ<\/code> and DATA<\/code> statements. read()<\/code> will take as input a variable name, and assign to it the next value taken from a DATA<\/code> statement. pushData()<\/code> will take a vector of doubles, and put them into the data value deque:<\/p>\n
public:\r\n\r\n...\r\n\r\n\tvoid read(std::string var);\t\t\t\/\/ assign next data value to var\r\n\tvoid pushData(std::vector<double> vals);\t\/\/ push more values onto data vector<\/pre>\n
Finally, add a private member variable to store the DATA<\/code> values:<\/p>\n
private:\r\n\r\n...\r\n\r\n\tstd::deque<double> data;\t\t\t\t\t\t\t\/\/ stored data block for READ<\/pre>\n
Moving on to the implementation in basic.cpp<\/em>, add the two new functions. read()<\/code> will take advantage of our existing assign()<\/code> function. pushData()<\/code> will iterate through the values in its input vector and push them onto the data<\/code> variable:<\/p>\n
\/\/ assign next data value to var\r\nvoid Basic::read(std::string var){\r\n\tassign(var, data.front());\r\n\tdata.pop_front();\r\n}\r\n\r\n\/\/ push more values onto data vector\r\nvoid Basic::pushData(std::vector<double> vals){\r\n\tfor( std::vector<double>::iterator it = vals.begin(); it != vals.end(); ++it ){\r\n\t\tdata.push_back(*it);\r\n\t}\r\n}<\/pre>\n
We also need to modify the execute()<\/code> function to add our pre-evaluation loop. This will run through all the Program<\/code> instances stored in our lines<\/code> map and call preExecute()<\/code>, a function which we will add to the Program<\/code> class:<\/p>\n
\/\/ run the program\r\nvoid Basic::execute(){\r\n\tdata.clear(); \/\/ clear any existing stored data\r\n\tfor( map<int, const Program *>::iterator it = lines.begin(); it!= lines.end(); ++it ){\r\n\t\tit->second->preExecute();\r\n\t}\r\n \r\n\tcounter = lines.begin();\r\n\twhile( counter != lines.end() )\r\n\t\tcounter->second->execute();\r\n}<\/pre>\n
Next, we’ll add the preExecute() function to our Program<\/code> class. Here is the new signature in the header file, <\/code><\/code><\/code>program.h<\/em>:<\/code><\/code><\/p>\n
class Program{\r\npublic:\r\n\tvirtual void execute() const;\t\t\t\/\/ run this line of the program\r\n\tvirtual void list(std::ostream& os) const;\t\/\/ list this line\r\n\tvirtual void preExecute() const;\t\t\/\/ run before main program execution\r\n};<\/pre>\n
Since this function is only used by one specialized subclass, the implementation in program.cpp<\/em> doesn’t do anything:<\/p>\n
\/\/ nothing to do here...\r\nvoid Program::preExecute() const{\r\n}<\/pre>\n
Now we will add the Data<\/code> class to handle the DATA<\/code> statement. Like usual, it will be a subclass of Program<\/code>. Unlike usual, it will not override the execute()<\/code> function, since it only has activity in the preExecute()<\/code> phase. Here is the header file, data.h<\/em>:<\/p>\n
#ifndef _DATA_H_\r\n#define _DATA_H_\r\n\r\n#include <vector>\r\n\r\n#include \"program.h\"\r\n\r\n\/*\r\nThis class implements the DATA statement, storing numbers\r\nfor later use by READ.\r\n*\/\r\nclass Data : public Program {\r\npublic:\r\n\tData(std::vector<double> vals);\r\n\t\r\n\t\/\/ use parent 'execute' implementation\r\n\tvoid list(std::ostream& os) const;\t\/\/ list this line\r\n\tvoid preExecute() const;\t\t\/\/ run before main program execution\r\n\r\nprivate:\r\n\tstd::vector<double> vals;\t\t\/\/ doubles to be stored\r\n};\r\n\r\n#endif<\/pre>\n
In the implementation, the constructor will take a vector of doubles, and store it in val<\/code>. The list()<\/code> function will do the normal listing of the statement, and preExecute()<\/code> will load the numerical values into the Basic<\/code> data storage variable. Note that because list()<\/code> is declared const<\/code>, we must use a const_iterator<\/code> access to the member variable vals<\/code>, along with the corresponding cbegin()<\/code> and cend()<\/code> iterator functions. Here is data.cpp<\/em>:<\/p>\n
#include \"data.h\"\r\n#include \"basic.h\"\r\n\r\nData::Data(std::vector<double> vals){\r\n\tthis->vals = vals;\r\n}\r\n\r\n\/\/ list this line\r\nvoid Data::list(std::ostream& os) const{\r\n\tos << \"DATA \";\r\n\tstd::vector<double>::const_iterator it = vals.cbegin();\r\n\tos << *it;\t\t\/\/ print out first value\r\n\tfor(  ++it; it != vals.cend(); ++it ){\r\n\t\tos << \", \" << *it; \/\/ print out remaining values\r\n\t}\r\n}\r\n\r\n\/\/ run before main program execution\r\nvoid Data::preExecute() const{\r\n\tBasic::instance()->pushData(vals);\r\n}<\/pre>\n
The Read<\/code> class also subclasses Program<\/code>. It stores a vector of strings representing variables names to be assigned values from a DATA<\/code> statement. Here is the header file, read.h:<\/em><\/p>\n
#ifndef _READ_H_\r\n#define _READ_H_\r\n\r\n#include <vector>\r\n#include <string>\r\n\r\n#include \"program.h\"\r\n\r\n\/*\r\nThis class supports the READ statement, putting pre-stored DATA\r\ninto specified variables.\r\n*\/\r\nclass Read : public Program {\r\npublic:\r\n\tRead(std::vector<std::string> vars);\r\n\t\r\n\tvoid execute() const;\t\t\t\/\/ run this line of the program\r\n\tvoid list(std::ostream& os) const;\t\/\/ list this line\r\n\r\nprivate:\r\n\tstd::vector<std::string> vars;\t\t\/\/ variables names to receive values\r\n};\r\n\r\n#endif<\/pre>\n
Here is the implementation, read.cpp<\/em>:<\/p>\n
#include \"read.h\"\r\n#include \"basic.h\"\r\n\r\nRead::Read(std::vector<std::string> vars){\r\n\tthis->vars = vars;\r\n}\r\n\r\n\/\/ run this line of the program\r\nvoid Read::execute() const{\r\n\tfor( std::vector<std::string>::const_iterator it = vars.cbegin(); it != vars.cend(); ++it ){\r\n\t\tBasic::instance()->read(*it);\r\n\t}\r\n\tProgram::execute();\r\n}\r\n\r\n\/\/ list this line\r\nvoid Read::list(std::ostream& os) const{\r\n\tos << \"READ \";\r\n\tstd::vector::const_iterator it = vars.cbegin();\r\n\tos << *it;\t\t\/\/ print out first value\r\n\tfor(  ++it; it != vars.cend(); ++it ){\r\n\t\tos << \", \" << *it;\t\/\/ print out remaining values\r\n\t}\r\n\r\n}\r\n<\/pre>\n
That is all for the C++ classes, so we will now move on to the flex and Bison files. The flex change for this is very simple, we just need to read and return two new tokens that will be defined in the Bison input file:<\/p>\n
DATA\t\t\t{ return DATA; }\r\nREAD\t\t\t{ return READ; }<\/pre>\n
In the Bison input file, first include our two new header files:<\/p>\n
#include \"read.h\"\r\n#include \"data.h\"<\/pre>\n
Next, we need to add a couple new types to the token union definition, one for string lists, and one for double lists:<\/p>\n
\/\/ token type definition\r\n%union {\r\n\tint iVal;\r\n\tdouble dVal;\r\n\tchar *sVal;\r\n\tProgram *progVal;\r\n\tExpression *eVal;\r\n\tDoubleExpression *dxVal;\r\n\tstd::vector<Expression*> *eList;\r\n\tstd::vector<std::string> *sList;\r\n\tstd::vector<double> *dList;\r\n}<\/pre>\n
Create two new constant tokens for the new statements:<\/p>\n
%token DATA\r\n%token READ<\/pre>\n
Add two new non-terminal symbols for new rules we will create to handle string lists and double lists:<\/p>\n
%type <sList> stringList\r\n%type <dList> doubleList<\/pre>\n
Extend the program<\/code> rule to handle our new statements, making use of our new constant tokens and non-terminal symbols:<\/p>\n
program:\r\n\r\n...\r\n\r\n\t| READ stringList\t\t{ $$ = new Read(*$2); }\r\n\t| DATA doubleList\t\t{ $$ = new Data(*$2); }\r\n;<\/pre>\n
Finally, we need to add the rules for our new stringList<\/code> and doubleList<\/code> non-terminal symbols. Similarly to the exprList<\/code> rule we already have, the stringList<\/code> will consist of one VAR<\/code> symbol, optionally followed by any number of COMMA VAR<\/code> pairs. The doubleList<\/code> actually needs to be able to handle integers as well as floating point numbers, so it will consist of either an INT<\/code> or a DOUBLE<\/code> token to start with, optionally followed by more INT<\/code> and\/or DOUBLE<\/code> tokens, separated again by commas:<\/p>\n
stringList:\r\n\tVAR\t\t\t\t{ $$ = new std::vector(1, $1); }\r\n\t| stringList COMMA VAR\t\t{\r\n\t\t\t\t\t\t$1->push_back($3);\r\n\t\t\t\t\t\t$$ = $1;\r\n\t\t\t\t\t}\r\n;\r\n\r\ndoubleList:\r\n\tDOUBLE\t\t\t\t{ $$ = new std::vector(1, $1); }\r\n\t| INT\t\t\t\t{ $$ = new std::vector(1, $1); }\r\n\t| doubleList COMMA DOUBLE\t{\r\n\t\t\t\t\t\t$1->push_back($3);\r\n\t\t\t\t\t\t$$ = $1;\r\n\t\t\t\t\t}\r\n\t| doubleList COMMA INT\t\t{\r\n\t\t\t\t\t\t$1->push_back($3);\r\n\t\t\t\t\t\t$$ = $1;\r\n\t\t\t\t\t}\r\n;<\/pre>\n
That’s all the code. Now add the new Read<\/code> and Data<\/code> class files to your Makefile, and build and run. Here is a sample session:<\/em><\/p>\n
Welcome to BASIC!\r\nEnter a program name: readdata\r\n>10 data 1\r\n>20 read x, y\r\n>40 print x, y\r\n>50 data 2\r\n>run\r\n1.000000 2.000000<\/pre>\n
As always, the complete source files are available here: https:\/\/github.com\/VisceralLogic\/basic\/tree\/part-6<\/a><\/p>\n
Continue to\u00a0Part VII<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
This is a continuation of Part V. In the previous section, we added support for the GOTO statement. Since we don’t yet have any control logic, that is not very useful, but it does lay the infrastructure for one of the features we will add this time: IF-THEN. We will also add the READ and […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"spay_email":"","jetpack_publicize_message":"","jetpack_is_tweetstorm":false},"categories":[12,16,13,15],"tags":[],"jetpack_featured_media_url":"","jetpack_publicize_connections":[],"jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9npkn-27","jetpack_likes_enabled":true,"jetpack-related-posts":[{"id":149,"url":"https:\/\/www.viscerallogic.com\/programming\/blog\/basic-interpreter-part-vii\/","url_meta":{"origin":131,"position":0},"title":"Basic Interpreter, Part VII","date":"September 7, 2018","format":false,"excerpt":"This is a continuation of Part VI. This time, we will be adding the FOR-NEXT loop and unary negation. The FOR-NEXT loop takes a couple forms: FOR  =  TO  ... NEXT  or FOR  =  TO  STEP  ... NEXT  In the former\u2026","rel":"","context":"In "BASIC"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":46,"url":"https:\/\/www.viscerallogic.com\/programming\/blog\/basic-interpreter-part-ii\/","url_meta":{"origin":131,"position":1},"title":"BASIC Interpreter, Part II","date":"September 7, 2018","format":false,"excerpt":"This is a continuation of Part I. In Part II, we will add functionality to store and run BASIC programs, although still limited to the PRINT statement. We will also be adding a LIST statement to print out the currently stored program. We will be adding a number of new\u2026","rel":"","context":"In "BASIC"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":90,"url":"https:\/\/www.viscerallogic.com\/programming\/blog\/basic-interpreter-part-iv\/","url_meta":{"origin":131,"position":2},"title":"BASIC Interpreter, Part IV","date":"September 7, 2018","format":false,"excerpt":"This is a continuation of Part III. This time we will add some mathematical operators, the ability to save and load programs, and support numerical variables. To enable mathematical operations, we will create a subclass of DoubleExpression that takes two DoubleExpressions as inputs, as well as a character code signifying\u2026","rel":"","context":"In "BASIC"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":111,"url":"https:\/\/www.viscerallogic.com\/programming\/blog\/basic-interpreter-part-v\/","url_meta":{"origin":131,"position":3},"title":"BASIC Interpreter, Part V","date":"September 7, 2018","format":false,"excerpt":"This is a continuation of Part IV. In Part V we will add support for parentheses in mathematical expressions, add the GOTO and END statements, and implement the remaining program storage statements: CATALOG, SCRATCH, and RENAME. Now that we have a framework for supporting numerical operations, adding parentheses is not\u2026","rel":"","context":"In "BASIC"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":72,"url":"https:\/\/www.viscerallogic.com\/programming\/blog\/basic-interpeter-part-iii\/","url_meta":{"origin":131,"position":4},"title":"BASIC Interpeter, Part III","date":"September 7, 2018","format":false,"excerpt":"This is a continuation of Part II. In this part, we will add support for numerical as well as string expressions, support multiple expression in a PRINT statement, and add functionality for deleting program lines. Let's start with the Basic class header file, basic.h. All we need to do here\u2026","rel":"","context":"In "BASIC"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":3,"url":"https:\/\/www.viscerallogic.com\/programming\/blog\/numerical-expression-solver-in-java\/","url_meta":{"origin":131,"position":5},"title":"Numerical Expression Solver in Java","date":"November 12, 2005","format":false,"excerpt":"This tutorial will show you how to write a Java program that takes a string input such as \"3 + 4^2*7.5E-1*sin(22)\" and convert it into a numerical answer, 2.893784 in this case, which you can use for whatever purpose you like. This Java Applet utilizes the Expression class that you\u2026","rel":"","context":"In "Java"","img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/posts\/131"}],"collection":[{"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/comments?post=131"}],"version-history":[{"count":10,"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/posts\/131\/revisions"}],"predecessor-version":[{"id":171,"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/posts\/131\/revisions\/171"}],"wp:attachment":[{"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/media?parent=131"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/categories?post=131"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.viscerallogic.com\/programming\/blog\/wp-json\/wp\/v2\/tags?post=131"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}