{"id":839,"date":"2010-11-08T22:43:00","date_gmt":"2010-11-08T15:43:00","guid":{"rendered":"http:\/\/it4bus.vn\/itersdesktop\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/"},"modified":"2014-01-03T05:44:04","modified_gmt":"2014-01-02T22:44:04","slug":"bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile","status":"publish","type":"post","link":"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/","title":{"rendered":"Bi\u00ean d\u1ecbch ch\u01b0\u01a1ng tr\u00ecnh C\/C++ t\u1ef1 \u0111\u1ed9ng b\u1eb1ng vi\u1ec7c t\u1ea1o makefile"},"content":{"rendered":"<p><a href=\"http:\/\/users.actcom.co.il\/~choo\/lupg\/tutorials\/writing-makefiles\/writing-makefiles.html\">\u0110\u00e2y<\/a> l\u00e0 m\u1ed9t b\u00e0i vi\u1ebft kh\u00e1 ho\u00e0n ch\u1ec9nh v\u00e0 l\u00fd th\u00fa. Qua b\u00e0i n\u00e0y v\u00e0 m\u1ed9t s\u1ed1 tham kh\u1ea3o kh\u00e1c tr\u00ean m\u1ea1ng, t\u1ea1m copy c\u00e1ch l\u00e0m nh\u01b0 sau:<br \/><span><\/p>\n<div id=\"ez-toc-container\" class=\"ez-toc-v2_0_83 counter-hierarchy ez-toc-counter ez-toc-light-blue ez-toc-container-direction\">\n<p class=\"ez-toc-title\" style=\"cursor:inherit\">Table of Contents<\/p>\n<label for=\"ez-toc-cssicon-toggle-item-6a14c4326dac2\" class=\"ez-toc-cssicon-toggle-label\"><span class=\"\"><span class=\"eztoc-hide\" style=\"display:none;\">Toggle<\/span><span class=\"ez-toc-icon-toggle-span\"><svg style=\"fill: #999;color:#999\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" class=\"list-377408\" width=\"20px\" height=\"20px\" viewBox=\"0 0 24 24\" fill=\"none\"><path d=\"M6 6H4v2h2V6zm14 0H8v2h12V6zM4 11h2v2H4v-2zm16 0H8v2h12v-2zM4 16h2v2H4v-2zm16 0H8v2h12v-2z\" fill=\"currentColor\"><\/path><\/svg><svg style=\"fill: #999;color:#999\" class=\"arrow-unsorted-368013\" xmlns=\"http:\/\/www.w3.org\/2000\/svg\" width=\"10px\" height=\"10px\" viewBox=\"0 0 24 24\" version=\"1.2\" baseProfile=\"tiny\"><path d=\"M18.2 9.3l-6.2-6.3-6.2 6.3c-.2.2-.3.4-.3.7s.1.5.3.7c.2.2.4.3.7.3h11c.3 0 .5-.1.7-.3.2-.2.3-.5.3-.7s-.1-.5-.3-.7zM5.8 14.7l6.2 6.3 6.2-6.3c.2-.2.3-.5.3-.7s-.1-.5-.3-.7c-.2-.2-.4-.3-.7-.3h-11c-.3 0-.5.1-.7.3-.2.2-.3.5-.3.7s.1.5.3.7z\"\/><\/svg><\/span><\/span><\/label><input type=\"checkbox\"  id=\"ez-toc-cssicon-toggle-item-6a14c4326dac2\"  aria-label=\"Toggle\" \/><nav><ul class='ez-toc-list ez-toc-list-level-1 ' ><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-1\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#preface\" >Preface<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-2\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#the-structure-of-a-makefile\" >The Structure Of A Makefile<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-3\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#order-of-compilation\" >Order Of Compilation<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-4\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#starting-small-%e2%80%93-a-single-source-makefile-example\" >Starting Small &#8211; A Single-Source Makefile Example<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-5\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#getting-bigger-%e2%80%93-a-multi-source-makefile-example\" >Getting Bigger &#8211; A Multi-Source Makefile Example<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-6\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#using-compiler-and-linker-flags\" >Using Compiler And Linker Flags<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-7\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#a-rule-for-everyone-%e2%80%93-using-%c2%ab-file-type-%c2%bb-rules\" >A Rule For Everyone &#8211; Using \u00ab\u00a0File Type\u00a0\u00bb Rules<\/a><\/li><li class='ez-toc-page-1 ez-toc-heading-level-2'><a class=\"ez-toc-link ez-toc-heading-8\" href=\"https:\/\/www.itersdesktop.com\/fr\/2010\/11\/08\/bien-dich-chuong-trinh-cc-tu-dong-bang-viec-tao-makefile\/#automatic-creation-of-dependencies\" >Automatic Creation Of Dependencies<\/a><\/li><\/ul><\/nav><\/div>\n<h2><span class=\"ez-toc-section\" id=\"preface\"><\/span>Preface<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   Compiling a program made of one source file is easy. Compiling one made of few sources is slightly annoying, but may be automated via a simple shell script. Anything larger than that would start to get on your nerves. This is where makefiles are helpful. <br \/>A makefile is a collection of instructions that should be used to compile  your program. Once you modify some source files, and type the command \u00ab\u00a0make\u00a0\u00bb (or \u00ab\u00a0gmake\u00a0\u00bb if using GNU&rsquo;s make), your program will be recompiled using as few compilation commands as possible. Only the files you modified and those dependent upon them will be recompiled. Of-course, this is not done via usage of magic. You need to supply the rules for compiling various files and file types, and the list of dependencies between files (if file \u00ab\u00a0A\u00a0\u00bb was changed, then files \u00ab\u00a0B\u00a0\u00bb, \u00ab\u00a0C\u00a0\u00bb and \u00ab\u00a0D\u00a0\u00bb also  need to be re-compiled), but that only has to be done once. <\/p>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"the-structure-of-a-makefile\"><\/span>The Structure Of A Makefile<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   A typical makefile contains lines of the following types: <\/p>\n<ul>\n<li> <u>Variable Definitions<\/u> &#8211; these lines define values for variables.      For example:      \n<pre><code><br \/>     CFLAGS = -g -Wall<br \/>     SRCS = main.c file1.c file2.c<br \/>     CC = gcc<br \/><\/code><\/pre>\n<p>\n<\/li>\n<li> <u>Dependency Rules<\/u> &#8211; these lines define under what conditions a      given file (or a type of file) needs to be re-compiled, and how to      compile it. For example:      \n<pre><code><br \/>     main.o: main.c<br \/>             gcc -g -Wall -c main.c<br \/><\/code><\/pre>\n<p>This rule means that \u00ab\u00a0main.o\u00a0\u00bb has to be recompiled whenever \u00ab\u00a0main.c\u00a0\u00bb is      modified. The rule continues to tell us that in order to compile      \u00ab\u00a0main.o\u00a0\u00bb, the command <code>\"gcc -g -Wall -c main.c\"<\/code> needs to      be executed.<br \/>Note that each line in the commands list must begin with      a TAB character. \u00ab\u00a0make\u00a0\u00bb is quite picky about the makefile&rsquo;s syntax.      <\/p>\n<\/li>\n<li> <u>Comments<\/u> &#8211; Any line beginning with a \u00ab\u00a0#\u00a0\u00bb sign, or any line      that contains only white-space. <\/li>\n<\/ul>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"order-of-compilation\"><\/span>Order Of Compilation<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   When a makefile is executed, we tell the <code>make<\/code> command to compile a specific target. A target is just some name that appears at the beginning of a rule. It can be a name of a file to create, or just a name that is used as a starting point (such a target is also called a \u00ab\u00a0phony\u00a0\u00bb target). <br \/>When <code>make<\/code> Is invoked, it first evaluates all variable assignments, from top to bottom, and when it encounters a rule \u00ab\u00a0A\u00a0\u00bb whose target matches the given target (or the first rule, if no target was supplied), it tries to evaluate this rule. First, it tries to recursively handle the dependencies that appear in the rule. If a given dependency has no matching rule, but there is a file in the disk with this name, the dependency is assumed to be up-to-date. After all the dependencies were checked, and any of them required handling, or refers to a file newer than the target, the command list for rule \u00ab\u00a0A\u00a0\u00bb is executed, one command at a time. <br \/>This might appear a little complex, but the example in the next section will make things clear. <\/p>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"starting-small-%e2%80%93-a-single-source-makefile-example\"><\/span>Starting Small &#8211; A Single-Source Makefile Example<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   Lets first see a simple example of a makefile that is used to compile a program made of a single source file: <\/p>\n<pre><code><br \/><span># top-level rule to create the program.<\/span><br \/>all: main<br \/><br \/><span># compiling the source file.<\/span><br \/>main.o: main.c<br \/>        gcc -g -Wall -c main.c<br \/><br \/><span># linking the program.<\/span><br \/>main: main.o<br \/>        gcc -g main.o -o main<br \/><br \/><span># cleaning everything that can be automatically recreated with \"make\".<\/span><br \/>clean:<br \/>        \/bin\/rm -f main main.o<\/code><\/pre>\n<p>Few notes about this makefile: <\/p>\n<ol>\n<li> Not all rules have to be used in every invocation of      <code>make<\/code>. The \u00ab\u00a0clean\u00a0\u00bb rule, for example, is not normally used      when building the program, but it may be used to remove the object      files created, to save disk space. <\/li>\n<li> A rule doesn&rsquo;t need to have any dependencies. This means if we tell make      to handle its target, it will always execute its commands list, as in      the \u00ab\u00a0clean\u00a0\u00bb rule above. <\/li>\n<li> A rule doesn&rsquo;t need to have any commands. For example, the \u00ab\u00a0all\u00a0\u00bb rule      is just used to invoke other rules, but does not need any commands of      its own. It is just convenient to make sure that if someone runs      <code>make<\/code> without a target name, this rule will get executed, due      to being the first rule encountered. <\/li>\n<li> We used the full path to the \u00ab\u00a0rm\u00a0\u00bb command, instead of just typing \u00ab\u00a0rm\u00a0\u00bb,      because many users have this command aliased to something else (for      example, \u00ab\u00a0rm\u00a0\u00bb aliased to \u00ab\u00a0rm -i\u00a0\u00bb). By using a full path, we avoid any      aliases. <\/li>\n<\/ol>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"getting-bigger-%e2%80%93-a-multi-source-makefile-example\"><\/span>Getting Bigger &#8211; A Multi-Source Makefile Example<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   In anything but the simplest programs, we usually have more than one source file. This is where using a makefile starts to pay off. Making a change to one file requires re-compilation of only the modified file, and then re-linking the program. Here is an example of such a makefile: <\/p>\n<pre><code><br \/><span># top-level rule to compile the whole program.<\/span><br \/>all: prog<br \/><br \/><span># program is made of several source files.<\/span><br \/>prog: main.o file1.o file2.o<br \/>        gcc main.o file1.o file2.o -o prog<br \/><br \/><span># rule for file \"main.o\".<\/span><br \/>main.o: main.c file1.h file2.h<br \/>        gcc -g -Wall -c main.c<br \/><br \/><span># rule for file \"file1.o\".<\/span><br \/>file1.o: file1.c file1.h<br \/>        gcc -g -Wall -c file1.c<br \/><br \/><span># rule for file \"file2.o\".<\/span><br \/>file2.o: file2.c file2.h<br \/>        gcc -g -Wall -c file2.c<br \/><br \/><span># rule for cleaning files generated during compilations.<\/span><br \/>clean:<br \/>        \/bin\/rm -f prog main.o file1.o file2.o<\/code><\/pre>\n<p>Few notes: <\/p>\n<ul>\n<li> There is one rule here for each source file. This causes some redundancy,      but later on we&rsquo;ll see how to get rid of it. <\/li>\n<li> We add dependency on included files (file1.h, file2.h) where applicable.      If one of these interface-definition files changes, the files that      include it might need a re-compilation too. This is not always true,      but it is better to make a redundant compilation, than to have object      files that are not synchronized with the source code. <\/li>\n<\/ul>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"using-compiler-and-linker-flags\"><\/span>Using Compiler And Linker Flags<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   As one could see, there are many repetitive patterns in the rules for our makefile. For example, what if we wanted to change the flags for compilation, to use optimization (<code>-O<\/code>), instead of add debug info (<code>-g<\/code>)?  we would need to go and change this flag for each rule. This might not look like much work with 3 source files, but it will be tedious when we have few tens of files, possibly spread over few directories. <br \/>The solution to this problem is using variables to store various flags, and even command names. This is especially useful when trying to compile the same source code with different compilers, or on different platforms, where even a basic command such as \u00ab\u00a0rm\u00a0\u00bb might reside in a different directory on each platform. <br \/>Lets see the same makefile, but this time with the introduction of variables: <\/p>\n<pre><code><br \/><span># use \"gcc\" to compile source files.<\/span><br \/>CC = gcc<br \/><span># the linker is also \"gcc\". It might be something else with other compilers.<\/span><br \/>LD = gcc<br \/><span># Compiler flags go here.<\/span><br \/>CFLAGS = -g -Wall<br \/><span># Linker flags go here. Currently there aren't any, but if we'll switch to<\/span><br \/><span># code optimization, we might add \"-s\" here to strip debug info and symbols.<\/span><br \/>LDFLAGS =<br \/><span># use this command to erase files.<\/span><br \/>RM = \/bin\/rm -f<br \/><span># list of generated object files.<\/span><br \/>OBJS = main.o file1.o file2.o<br \/><span># program executable file name.<\/span><br \/>PROG = prog<br \/><br \/><span># top-level rule, to compile everything.<\/span><br \/>all: $(PROG)<br \/><br \/><span># rule to link the program<\/span><br \/>$(PROG): $(OBJS)<br \/>        $(LD) $(LDFLAGS) $(OBJS) -o $(PROG)<br \/><br \/><span># rule for file \"main.o\".<\/span><br \/>main.o: main.c file1.h file2.h<br \/>        $(CC) $(CFLAGS) -c main.c<br \/><br \/><span># rule for file \"file1.o\".<\/span><br \/>file1.o: file1.c file1.h<br \/>        $(CC) $(CFLAGS) -c file1.c<br \/><br \/><span># rule for file \"file2.o\".<\/span><br \/>file2.o: file2.c file2.h<br \/>        $(CC) $(CFLAGS) -c file2.c<br \/><br \/><span># rule for cleaning re-compilable files.<\/span><br \/>clean:<br \/>        $(RM) $(PROG) $(OBJS)<\/code><\/pre>\n<p>Few notes: <\/p>\n<ul>\n<li> We define many variables in this makefile. This will make it very easy      to modify compile flags, compiler used, etc. It is good practice to       define even things that might seem like they&rsquo;ll never change. In time &#8211;      they will. <\/li>\n<li> We still have a problem with the fact that we define one rule for each      source file. If we&rsquo;ll want to change this rule&rsquo;s format, it will be      rather tedious. The next section will show us how to avoid this problem. <\/li>\n<\/ul>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"a-rule-for-everyone-%e2%80%93-using-%c2%ab-file-type-%c2%bb-rules\"><\/span>A Rule For Everyone &#8211; Using \u00ab\u00a0File Type\u00a0\u00bb Rules<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>   So, the next phase would be to eliminate the redundant rules, and try to use one rule for all source files. After all, they are all compiled in the same way. Here is a modified makefile: <\/p>\n<pre><code><br \/><span># we'll skip all the variable definitions, just take them from the previous<\/span><br \/><span># makefile<\/span><br \/>.<br \/>.<br \/><span># linking rule remains the same as before.<\/span><br \/>$(PROG): $(OBJS)<br \/>        $(LD) $(LDFLAGS) $(OBJS) -o $(PROG)<br \/><br \/><span># now comes a meta-rule for compiling any \"C\" source file.<\/span><br \/>%.o: %.c<br \/>        $(CC) $(CFLAGS) -c $< <\/code><\/code><\/pre>\n<p>We should explain two things about our meta-rule: <\/p>\n<ol>\n<li> The \u00ab\u00a0%\u00a0\u00bb character is a wildcard, that matches any part of a file&rsquo;s name.      If we mention \u00ab\u00a0%\u00a0\u00bb several times in a rule, they all must match the same      value, for a given rule invocation. Thus, our rule here means \u00ab\u00a0A file      with a &lsquo;.o&rsquo; suffix is dependent on a file with the same name, but a &lsquo;.c&rsquo;      suffix\u00a0\u00bb. <\/li>\n<li> The \u00ab\u00a0$< \" string refers to the dependency list that was matched by the      rule (in our case - the full name of the source file).      There are other similar strings, such as \"$@\" which refers to the full      target name, or \"$*\", that refers the part that was matched by the      \"%\" character. <\/li>\n<\/li>\n<\/ol>\n<hr size=\"4\"\/>\n<span><\/p>\n<h2><span class=\"ez-toc-section\" id=\"automatic-creation-of-dependencies\"><\/span>Automatic Creation Of Dependencies<span class=\"ez-toc-section-end\"><\/span><\/h2>\n<p><\/span>  One problem with the usage of implicit rules, is that we lost the full list of dependencies, that are unique to each file. This can be overcome by using extra rules for each file, that only contain dependencies, but no commands. This can be added manually, or be automated in one of various ways. Here is one example, using the \u00ab\u00a0makedepend\u00a0\u00bb Unix program. <\/p>\n<pre><code><br \/><span># define the list of source files.<\/span><br \/>SRCS = main.c file1.c file2.c<br \/>.<br \/>.<br \/><span># most of the makefile remains as it was before.<\/span><br \/><span># at the bottom, we add these lines:<\/span><br \/><br \/><span># rule for building dependency lists, and writing them to a file<\/span><br \/><span># named \".depend\".<\/span><br \/>depend:<br \/>        $(RM) .depend<br \/>        makedepend -f- -- $(CFLAGS) -- $(SRCS) > .depend<br \/><br \/><span># now add a line to include the dependency list.<\/span><br \/>include .depend<\/code><\/pre>\n<p>Now, if we run \u00ab\u00a0make depend\u00a0\u00bb, the \u00ab\u00a0makedepend\u00a0\u00bb program will scan the given source files, create a dependency list for each of them, and write appropriate rules to the file \u00ab\u00a0.depend\u00a0\u00bb. Since this file is then included by the makefile, when we&rsquo;ll compile the program itself, these dependencies will be checked during program compilation. <br \/>There are many other ways to generate dependency lists. It is advised that programmers interested in this issue read about the compiler&rsquo;s \u00ab\u00a0-M\u00a0\u00bb flag, and read the manual page of \u00ab\u00a0makedepend\u00a0\u00bb carefully. Also note that gnu make&rsquo;s info pages suggest a different way of making dependency lists  created automatically when compiling a program. The advantage is that the dependency list never gets out of date. The disadvantage is that many times it is being run for no reason, thus slowing down the compilation phase. Only experimenting will show you exactly when to use each approach.<\/p>\n<p>Notes: Sorry the author of the article due to copyright.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>\u0110\u00e2y l\u00e0 m\u1ed9t b\u00e0i vi\u1ebft kh\u00e1 ho\u00e0n ch\u1ec9nh v\u00e0 l\u00fd th\u00fa. Qua b\u00e0i n\u00e0y v\u00e0 m\u1ed9t s\u1ed1 tham kh\u1ea3o kh\u00e1c tr\u00ean m\u1ea1ng, t\u1ea1m copy c\u00e1ch l\u00e0m nh\u01b0 sau: Preface Compiling&hellip; <\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[280,205],"tags":[204],"class_list":["post-839","post","type-post","status-publish","format-standard","hentry","category-code-management","category-compiler","tag-makefile"],"_links":{"self":[{"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/posts\/839","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/comments?post=839"}],"version-history":[{"count":1,"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/posts\/839\/revisions"}],"predecessor-version":[{"id":1211,"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/posts\/839\/revisions\/1211"}],"wp:attachment":[{"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/media?parent=839"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/categories?post=839"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.itersdesktop.com\/fr\/wp-json\/wp\/v2\/tags?post=839"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}