<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comentários sobre: Misra-C — Padrão para software em C</title>
	<atom:link href="http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/feed/" rel="self" type="application/rss+xml" />
	<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/?utm_source=rss&#038;utm_medium=rss&#038;utm_campaign=misra-c-padrao-para-software-em-c</link>
	<description>Sistemas embarcados, Linux e tecnologia</description>
	<lastBuildDate>Mon, 06 Feb 2012 12:08:00 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
		<item>
		<title>Por: Sérgio MacGyver</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-117</link>
		<dc:creator>Sérgio MacGyver</dc:creator>
		<pubDate>Mon, 02 Aug 2010 13:30:08 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-117</guid>
		<description>Caros S&#233;rgio e Murilo,
Pelo que entendi da regra 49, &quot;Tests of a value against zero should be made explicit, unless the operand is effec tively Boolean&quot;, no caso de &lt;strong&gt;bufferLen&lt;/strong&gt; temos que fazer compara&#231;&#245;es expl&#237;citas, pois &#233; um contador e n&#227;o efetivamente um booleano. J&#225; no caso de &lt;strong&gt;bufferVazio&lt;/strong&gt;, por se tratar efetivamente de um booleano, ainda que implicitamente um int, as compara&#231;&#245;es &lt;strong&gt;if (bufferVazio)&lt;/strong&gt; e &lt;strong&gt;if (!bufferVazio)&lt;/strong&gt; s&#227;o aceitas pelo MISRA-C.
[]s
S&#233;rgio</description>
		<content:encoded><![CDATA[<p>Caros Sérgio e Murilo,<br />
Pelo que entendi da regra 49, “Tests of a value against zero should be made explicit, unless the operand is effec tively Boolean”, no caso de <strong>bufferLen</strong> temos que fazer comparações explícitas, pois é um contador e não efetivamente um booleano. Já no caso de <strong>bufferVazio</strong>, por se tratar efetivamente de um booleano, ainda que implicitamente um int, as comparações <strong>if (bufferVazio)</strong> e <strong>if (!bufferVazio)</strong> são aceitas pelo MISRA-C.<br />
[]s<br />
Sérgio</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: sergioprado</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-116</link>
		<dc:creator>sergioprado</dc:creator>
		<pubDate>Fri, 30 Jul 2010 11:43:40 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-116</guid>
		<description>&lt;p&gt;Ol&#225; Murilo, tudo bem?&lt;/p&gt;
&lt;p&gt;Semanticamente, &quot;bufferVazio&quot; &#233; um booleano, mas sintaticamente ele continua sendo um int. O que o padr&#227;o quer nos dizer &#233; que devemos fazer as compara&#231;&#245;es explicitas, ou seja, se desejamos verificar se o buffer esta vazio, esta implementa&#231;&#227;o est&#225; fora do padr&#227;o:&lt;/p&gt;
&lt;p&gt;if (bufferVazio) { ... };&lt;/p&gt;
&lt;p&gt;E esta esta dentro do padr&#227;o:&lt;/p&gt;
&lt;p&gt;&lt;meta content=&quot;text/html; charset=utf-8&quot; http-equiv=&quot;content-type&quot; /&gt;if (bufferVazio == 1) { ... };&lt;/p&gt;
&lt;p&gt;Eu concordo com voc&#234;, e acho a primeira forma mais f&#225;cil de ler.&lt;/p&gt;
&lt;p&gt;Um abra&#231;o,&lt;/p&gt;
&lt;p&gt;Sergio Prado&lt;/p&gt;</description>
		<content:encoded><![CDATA[<p>Olá Murilo, tudo bem?</p>
<p>Semanticamente, “bufferVazio” é um booleano, mas sintaticamente ele continua sendo um int. O que o padrão quer nos dizer é que devemos fazer as comparações explicitas, ou seja, se desejamos verificar se o buffer esta vazio, esta implementação está fora do padrão:</p>
<p>if (bufferVazio) { … };</p>
<p>E esta esta dentro do padrão:</p>
<p><meta content="text/html; charset=utf-8" http-equiv="content-type" />if (bufferVazio == 1) { … };</p>
<p>Eu concordo com você, e acho a primeira forma mais fácil de ler.</p>
<p>Um abraço,</p>
<p>Sergio Prado</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: murilo</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-115</link>
		<dc:creator>murilo</dc:creator>
		<pubDate>Fri, 30 Jul 2010 04:57:09 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-115</guid>
		<description>Esse exemplo da regra 49.
&lt;code&gt;bufferVazio&lt;/code&gt; n&#227;o &#233; um booleano, mesmo que declarado como um &lt;code&gt;int&lt;/code&gt;?
Quero dizer, acho que essa regra diz para que n&#227;o fa&#231;amos algo do tipo:
&lt;code&gt;if (!buffer_len)&lt;/code&gt;
e que fa&#231;amos
&lt;code&gt;if (buffer_len == 0)&#160;&lt;/code&gt;
o que &#233; muito mais leg&#237;vel, o significaria &quot;se o tamanho do buffer for igual a 0&quot; ao inv&#233;s de &quot;se n&#227;o tamanho do buffer&quot;
Agora para o exemplo que voc&#234; disse, apesar de &lt;code&gt;bufferVazio&lt;/code&gt; ser provavelmente um int, ele assume valores booleanos ent&#227;o &lt;code&gt;!bufferVazio&lt;/code&gt; faz mais sentido &quot;se o buffer n&#227;o estiver vazio&quot;.
Um abra&#231;o,
Murilo</description>
		<content:encoded><![CDATA[<p>Esse exemplo da regra 49.<br />
<code>bufferVazio</code> não é um booleano, mesmo que declarado como um <code>int</code>?<br />
Quero dizer, acho que essa regra diz para que não façamos algo do tipo:<br />
<code>if (!buffer_len)</code><br />
e que façamos<br />
<code>if (buffer_len == 0)&nbsp;</code><br />
o que é muito mais legível, o significaria “se o tamanho do buffer for igual a 0″ ao invés de “se não tamanho do buffer“<br />
Agora para o exemplo que você disse, apesar de <code>bufferVazio</code> ser provavelmente um int, ele assume valores booleanos então <code>!bufferVazio</code> faz mais sentido “se o buffer não estiver vazio”.<br />
Um abraço,<br />
Murilo</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: Lucas Fernando Amorim</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-114</link>
		<dc:creator>Lucas Fernando Amorim</dc:creator>
		<pubDate>Sat, 26 Jun 2010 15:36:16 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-114</guid>
		<description>Parab&#233;ns Sergio,

	Ficou muito bom o seu artigo, padroniza&#231;&#227;o de c&#243;digo &#233; um assunto muito importante que merece ser discutido. Toda iniciativa de estiliza&#231;&#227;o &#233; ben&#233;fica, levando a uma maior manutenabilidade do software.

	Como sempre seu blog &#233; uma excelente fonte de informa&#231;&#245;es &#250;teis e profissionais.

	Abra&#231;o.</description>
		<content:encoded><![CDATA[<p>Parabéns Sergio,</p>
<p>	Ficou muito bom o seu artigo, padronização de código é um assunto muito importante que merece ser discutido. Toda iniciativa de estilização é benéfica, levando a uma maior manutenabilidade do software.</p>
<p>	Como sempre seu blog é uma excelente fonte de informações úteis e profissionais.</p>
<p>	Abraço.</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: sergioprado</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-113</link>
		<dc:creator>sergioprado</dc:creator>
		<pubDate>Sat, 19 Jun 2010 00:15:54 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-113</guid>
		<description>Olá xará! :)

Com relação à regra 49, quando uma variável representa um valor boolean, ou seja, que pode assumir apenas true (1) ou false (0), eu acho muito mais fácil de ler o código sem ter que comparar com 0 ou 1, como exige o padrão. Com relação à regra 20.4, você fez uma ótima observação. Ainda não tinha considerado esta hipótese. E o Hugo participa bastante do grupo sis_embarcados, do qual agora você também faz parte...:) Estou te enviando o email dele em PVT. Um abraço e continue acompanhando o blog!</description>
		<content:encoded><![CDATA[<p>Olá xará! :)</p>
<p>Com relação à regra 49, quando uma variável representa um valor boolean, ou seja, que pode assumir apenas true (1) ou false (0), eu acho muito mais fácil de ler o código sem ter que comparar com 0 ou 1, como exige o padrão. Com relação à regra 20.4, você fez uma ótima observação. Ainda não tinha considerado esta hipótese. E o Hugo participa bastante do grupo sis_embarcados, do qual agora você também faz parte…:) Estou te enviando o email dele em PVT. Um abraço e continue acompanhando o blog!</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: Sérgio MacGyver</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-112</link>
		<dc:creator>Sérgio MacGyver</dc:creator>
		<pubDate>Fri, 18 Jun 2010 21:16:12 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-112</guid>
		<description>Caro xar&#225;, &#160; :-)
&#160;
Pretendia comentar a regra 49, sobre os testes de vari&#225;vel zerada, mas vi que outros j&#225; teceram seus coment&#225;rios. No entanto, ap&#243;s voc&#234; acrescentar um coment&#225;rio reconhecendo que o if (!bufferVazio) &#233; permitido pelo MISRA-C, n&#227;o consigo entender em qu&#234; reside sua discord&#226;ncia do padr&#227;o.
&#160;
Quanto &#224; regra 20.4, sobre o dynamic heap memory allocation, creio que o padr&#227;o condena n&#227;o a aloca&#231;&#227;o din&#226;mica em si, mas o m&#233;todo utilizado (heap memory).
Existem outros esquemas de aloca&#231;&#227;o din&#226;mica em que a regi&#227;o aloc&#225;vel &#233; previamente particionada em blocos de tamanho fixo, sendo alguns menores e outros maiores. Quando um c&#243;digo solicita mem&#243;ria, tenta-se entregar um bloco que possua tamanho igual ou pouco maior que o solicitado, caso dispon&#237;vel. H&#225; perda de mem&#243;ria por entregar-se mais do que se pediu, mas n&#227;o h&#225; o famigerado problema de fragmenta&#231;&#227;o de mem&#243;ria, em que h&#225; mem&#243;ria suficiente, mas toda &quot;espalhada&quot; pelo heap.
Desconfio que seja justamente o problema de fragmenta&#231;&#227;o que esteja na causa das falhas comumente associadas &#224; aloca&#231;&#227;o de mem&#243;ria. Al&#233;m da falta de teste de retorno do malloc, claro.
&#160;
Por fim, concordo com sua discord&#226;ncia (pun intended) da regra 104. Sou adepto da programa&#231;&#227;o orientada a eventos (+maquinas de estados) em sistemas embarcados, e essa &#233; a melhor forma de se implementar eventos (com fun&#231;&#245;es de callback).
&#160;
Desconfio que o colega Hugo Sobreira &#233; um conhecido meu que trabalhou na Motorola e talvez conhe&#231;a o esquema de aloca&#231;&#227;o que citei acima. Se for voc&#234; mesmo, bom te ver por aqui, Hugo! (eu trabalhava no projeto CESAR-Motorola).
&#160;
S&#233;rgio, por favor, encaminhe esso meu coment&#225;rio pro email do Hugo. Obrigado!</description>
		<content:encoded><![CDATA[<p>Caro xará,   :-)<br />
 <br />
Pretendia comentar a regra 49, sobre os testes de variável zerada, mas vi que outros já teceram seus comentários. No entanto, após você acrescentar um comentário reconhecendo que o if (!bufferVazio) é permitido pelo MISRA-C, não consigo entender em quê reside sua discordância do padrão.<br />
 <br />
Quanto à regra 20.4, sobre o dynamic heap memory allocation, creio que o padrão condena não a alocação dinâmica em si, mas o método utilizado (heap memory).<br />
Existem outros esquemas de alocação dinâmica em que a região alocável é previamente particionada em blocos de tamanho fixo, sendo alguns menores e outros maiores. Quando um código solicita memória, tenta-se entregar um bloco que possua tamanho igual ou pouco maior que o solicitado, caso disponível. Há perda de memória por entregar-se mais do que se pediu, mas não há o famigerado problema de fragmentação de memória, em que há memória suficiente, mas toda “espalhada” pelo heap.<br />
Desconfio que seja justamente o problema de fragmentação que esteja na causa das falhas comumente associadas à alocação de memória. Além da falta de teste de retorno do malloc, claro.<br />
 <br />
Por fim, concordo com sua discordância (pun intended) da regra 104. Sou adepto da programação orientada a eventos (+maquinas de estados) em sistemas embarcados, e essa é a melhor forma de se implementar eventos (com funções de callback).<br />
 <br />
Desconfio que o colega Hugo Sobreira é um conhecido meu que trabalhou na Motorola e talvez conheça o esquema de alocação que citei acima. Se for você mesmo, bom te ver por aqui, Hugo! (eu trabalhava no projeto CESAR-Motorola).<br />
 <br />
Sérgio, por favor, encaminhe esso meu comentário pro email do Hugo. Obrigado!</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: sergioprado</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-111</link>
		<dc:creator>sergioprado</dc:creator>
		<pubDate>Wed, 09 Jun 2010 01:27:24 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-111</guid>
		<description>Olá Hugo!

Seu comentário é quase um novo post...:)

Obrigado pelas dicas valiosas e continue aparecendo por aqui.

Um abraço!</description>
		<content:encoded><![CDATA[<p>Olá Hugo!</p>
<p>Seu comentário é quase um novo post…:)</p>
<p>Obrigado pelas dicas valiosas e continue aparecendo por aqui.</p>
<p>Um abraço!</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: Hugo Sobreira</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-110</link>
		<dc:creator>Hugo Sobreira</dc:creator>
		<pubDate>Tue, 08 Jun 2010 17:15:36 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-110</guid>
		<description>Caro Sergio,

	Parabens pela iniciativa, de fato sinto falta de artigos relacionados ao tema na nossa l&#237;ngua portuguesa.
Venho trabalhando com desenvolvimento de sistemas cr&#237;ticos j&#225; h&#225; alguns anos e hoje utilizo a MISRA-C como padr&#227;o de codifica&#231;&#227;o. Vale &#224; pena ressaltar a diferen&#231;a entre padr&#227;o de codifica&#231;&#227;o e padr&#227;o de desenvolvimento (ou design). Para desenvolver sistemas cr&#237;ticos &#233; necesssario ter estes padr&#245;es definidos. Interessante notar tamb&#233;m que adoptar uma padr&#227;o de codifica&#231;&#227;o n&#227;o &#233; apenas boa pr&#225;tica quando se trata de sistemas cr&#237;ticos (SC): &#233; mesmo uma obriga&#231;&#227;o. Padr&#245;es de codifica&#231;&#227;o s&#227;o requeridos por diferentes normas que defendem desenvolvimento de SC (veja a DO-178B, IEC-61508, EN-50128).
Quanto ao padr&#227;o MISRA-C, os justificativas para cada regra s&#227;o muito bem explicadas na pr&#243;pria norma, por isso recomendo sua leitura a qualquer um que pense seriamente em aplic&#225;-la. L&#225; vc vai ver tamb&#233;m que nem todas as regras s&#227;o normativas, h&#225; tamb&#233;m regras opcionais.

	O que tenho visto como experi&#234;ncia geral &#233; que MISRA-C n&#227;o tem por prop&#243;sito somente &quot;educar&quot; desenvolvedores inexperientes. Desenvolver software para SC pode ser uma tarefa extremamente &#225;rdua pelo simples fato de constru&#231;&#245;es mais elaboradas da linguagem n&#227;o serem permitidas.Tomando como exemplo a regra comentada em seu artigo sobre aloca&#231;&#227;o din&#226;mica de mem&#243;ria (regra 20.4, uma das requeridas pela norma). Num sistema cr&#237;tico, &#233; imprescind&#237;vel saber a priori quantos e quais s&#227;o os recursos utilizados pela aplica&#231;&#227;o. Mais que isso, &#233; preciso demonstrar, que a quantidade de mem&#243;ria utilizada nunca ultrapassar&#225; o limite dispon&#237;vel (suponha que o programa falhe de uma maneira catastr&#243;fica caso n&#227;o haja mem&#243;ria dispon&#237;vel). Quando se usa aloca&#231;&#227;o din&#226;mica de mem&#243;ria &#233; extremamente dif&#237;cil provar esta &#039;propriedade&#039;. Portanto MISRA-C fala muito tamb&#233;m &#224; comunidade de programadores experientes em C, mas que podem n&#227;o estar devidamente contextualizados as necessidades da natureza deste tipo de aplica&#231;&#227;o.

	Abra&#231;os,
Hugo Sobreira</description>
		<content:encoded><![CDATA[<p>Caro Sergio,</p>
<p>	Parabens pela iniciativa, de fato sinto falta de artigos relacionados ao tema na nossa língua portuguesa.<br />
Venho trabalhando com desenvolvimento de sistemas críticos já há alguns anos e hoje utilizo a MISRA-C como padrão de codificação. Vale à pena ressaltar a diferença entre padrão de codificação e padrão de desenvolvimento (ou design). Para desenvolver sistemas críticos é necesssario ter estes padrões definidos. Interessante notar também que adoptar uma padrão de codificação não é apenas boa prática quando se trata de sistemas críticos (SC): é mesmo uma obrigação. Padrões de codificação são requeridos por diferentes normas que defendem desenvolvimento de SC (veja a DO-178B, IEC-61508, EN-50128).<br />
Quanto ao padrão MISRA-C, os justificativas para cada regra são muito bem explicadas na própria norma, por isso recomendo sua leitura a qualquer um que pense seriamente em aplicá-la. Lá vc vai ver também que nem todas as regras são normativas, há também regras opcionais.</p>
<p>	O que tenho visto como experiência geral é que MISRA-C não tem por propósito somente “educar” desenvolvedores inexperientes. Desenvolver software para SC pode ser uma tarefa extremamente árdua pelo simples fato de construções mais elaboradas da linguagem não serem permitidas.Tomando como exemplo a regra comentada em seu artigo sobre alocação dinâmica de memória (regra 20.4, uma das requeridas pela norma). Num sistema crítico, é imprescindível saber a priori quantos e quais são os recursos utilizados pela aplicação. Mais que isso, é preciso demonstrar, que a quantidade de memória utilizada nunca ultrapassará o limite disponível (suponha que o programa falhe de uma maneira catastrófica caso não haja memória disponível). Quando se usa alocação dinâmica de memória é extremamente difícil provar esta ‘propriedade’. Portanto MISRA-C fala muito também à comunidade de programadores experientes em C, mas que podem não estar devidamente contextualizados as necessidades da natureza deste tipo de aplicação.</p>
<p>	Abraços,<br />
Hugo Sobreira</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: sergioprado</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-109</link>
		<dc:creator>sergioprado</dc:creator>
		<pubDate>Tue, 08 Jun 2010 16:53:44 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-109</guid>
		<description>Olá Rudolf,

Ótima observação. A minha interpretação é que a regra quis dizer que você não precisa fazer uma comparação explicita apenas se sua variável for do tipo boolean. O exemplo abaixo é permitido pelo padrão MISRA-C:

bool bufferVazio;

if (bufferVazio) {
    return;
}

Veja que a variável &quot;bufferVazio&quot; é do tipo bool. O tipo bool está especificado no padrão ANSI C99.

Um abraço,

Sergio Prado</description>
		<content:encoded><![CDATA[<p>Olá Rudolf,</p>
<p>Ótima observação. A minha interpretação é que a regra quis dizer que você não precisa fazer uma comparação explicita apenas se sua variável for do tipo boolean. O exemplo abaixo é permitido pelo padrão MISRA-C:</p>
<p>bool bufferVazio;</p>
<p>if (bufferVazio) {<br />
    return;<br />
}</p>
<p>Veja que a variável “bufferVazio” é do tipo bool. O tipo bool está especificado no padrão ANSI C99.</p>
<p>Um abraço,</p>
<p>Sergio Prado</p>
]]></content:encoded>
	</item>
	<item>
		<title>Por: Rudolf Waller</title>
		<link>http://sergioprado.org/2010/05/27/misra-c-padrao-para-software-em-c/#comment-108</link>
		<dc:creator>Rudolf Waller</dc:creator>
		<pubDate>Tue, 08 Jun 2010 13:32:49 +0000</pubDate>
		<guid isPermaLink="false">http://www.sergioprado.org/?p=527#comment-108</guid>
		<description>Oi Sergio,
&#160;
Dei uma pesquisada e vi que as regras 49 e 104 que voc&#234; citou &#233; do MISRA-C:1998. N&#227;o achei o equivalente destas regras na vers&#227;o de 2004.
&#160;
Abra&#231;os,
Rudolf</description>
		<content:encoded><![CDATA[<p>Oi Sergio,<br />
 <br />
Dei uma pesquisada e vi que as regras 49 e 104 que você citou é do MISRA-C:1998. Não achei o equivalente destas regras na versão de 2004.<br />
 <br />
Abraços,<br />
Rudolf</p>
]]></content:encoded>
	</item>
</channel>
</rss>

