-
Notifications
You must be signed in to change notification settings - Fork 2
/
LERPARM.H
463 lines (398 loc) · 15.2 KB
/
LERPARM.H
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
#if ! defined( LerParm_ )
#define LerParm_
/***************************************************************************
*
* $MCD Módulo de definição: LER Ler parâmetros de comandos
*
* Arquivo gerado: LerParm.h
* Letras identificadoras: LER
*
* Nome da base de software: Arcabouço para a automação de testes de programas redigidos em C
* Arquivo da base de software: C:\AUTOTEST\PROJETOS\ARCABOUC.BSW
*
* Projeto: INF 1301 / 1628 Automatização dos testes de módulos C
* Gestor: LES/DI/PUC-Rio
* Autores: avs
*
* $HA Histórico de evolução:
* Versão Autor Data Observações
* 4 avs 01/fev/2006 criar linguagem script simbólica
* 3 avs 08/dez/2004 uniformização dos exemplos
* 2 avs 07/jul/2003 unificação de todos os módulos em um só projeto
* 1 avs 16/abr/2003 início desenvolvimento
*
* $ED Descrição do módulo
* Provê funções para a leitura e análise léxica dos comandos de teste.
* Pressupõe-se que cada comando de teste esteja integralmente em
* uma linha.
* Cada comando de teste inicia com o caractere '=' seguido de um string
* que identifica o comando.
* Cada comando pode requerer zero ou mais parâmetros que se encontram na
* mesma linha que o comando.
* Parâmetros podem ser literis ou simbólicos.
* Os parâmetros simbólicos precisam ser declarados antes de serem
* utilizados.
* Os parâmetros têm tipo e a leitura deve respeitar esses tipos.
*
* Se for do interesse do programador, módulos de teste específico
* podem ler e processar por conta própria linhas do script. Isto
* pode ser necessário quando um módulo necessita de um grande
* número de parâmetros ou de dados especiais.
*
* $EIU Interface com o usuário pessoa
* Este módulo interpreta os comandos de teste globalmente disponíveis:
*
* =declararparm <nome> <idTipo> <literal>
* declara o parâmetro <nome> do <tipo> definido com o valor <literal>
* <tipo> pode ser um de:
* i - inteiro (long)
* f - flutuante (double)
* c - caractere
* s - string
* O valor de literal tem que estar em conformidade com o tipo
*
* =exibirdeclaracao <nome>
* exibe a declaração do parâmetro <nome> em formato "dump de memória"
*
* Literais devem obedecer às regras léxicas utilizadas pela linguagem C.
*
* Estes comandos sempre estarão disponíveis. Os demais comandos de
* teste estão impementados no módulo TESTLER específico para este módulo.
*
***************************************************************************/
#if defined( LerParm_OWN )
#define LerParm_EXT
#else
#define LerParm_EXT extern
#endif
/***** Declarações exportadas pelo módulo *****/
#define LER_DIM_NOME 32
#define LER_DIM_STRING 500
#define LER_DIM_BUFFER 250
/***********************************************************************
*
* $TC Tipo de dados: LER Condições de retorno
*
*
***********************************************************************/
typedef enum {
LER_CondRetOK ,
/* Ler retorno OK */
LER_CondRetNaoAbriu
/* Ler não abriu arquivo */
} LER_tpCondRet ;
/***** Dados exportados pelo módulo *****/
/* Estrutura de dados: *LER Dados globais públicos */
LerParm_EXT int LER_TamBuffer ;
/* Tamanho do string contido no buffer de leitura
*
*$ED Descrição
* Contém o número total de caracteres do buffer, excluindo o zero.
* Jamais altere este valor. */
LerParm_EXT int LER_InxBuffer ;
/* Cursor do buffer de leitura
*
*$ED Descrição
* O cursor de leitura indexa o primeiro caractere não lido contido
* no buffer.
* O cursor é zerado sempre que uma nova linha for lida.
* O cursor é avançado ao ler um parâmetro, sendo colocado no
* primeiro caractere imediatamente após ao parâmetro lido.
* Evite acessar caracteres quando LER_InxBuffer > LER_TamBuffer */
LerParm_EXT char LER_Buffer[ LER_DIM_BUFFER + 1 ] ;
/* Buffer de leitura
*
*$ED Descrição
* Contém a linha corrente do script a ser processada.
* Jamais altere o valor do buffer. */
/***********************************************************************
*
* $FC Função: LER &Inicializar módulo LerParm
*
* $ED Descrição da função
* Inicializa o módulo.
* Deve ser chamada antes de iniciar a análise de comandos.
* Deve ser chamada uma única vez no início ou após terminar o módulo.
*
***********************************************************************/
int LER_InicializarLeitura( void ) ;
/***********************************************************************
*
* $FC Função: LER &Terminar módulo LerParm
*
* $ED Descrição da função
* Fecha o arquivo de leitura e sinaliza módulo de leitura não
* inicializado.
* Após esta função somente poderá ser chamada a funçãp
* LER_InicializarLeitura
*
***********************************************************************/
void LER_TerminarLeitura( void ) ;
/***********************************************************************
*
* $FC Função: LER &Obter nome do arquivo script
*
* $FV Valor retornado
* Retorna o ponteiro para o nome do arquivo script sendo processado.
* Deve-se tomar cuidado para não alterar este nome.
* Será NULL se nãa tem arquivo aberto ou o módulo não está inicializado.
*
***********************************************************************/
char * LER_ObterNomeArqScript( void ) ;
/***********************************************************************
*
* $FC Função: LER &Obter número de linhas lidas até o momento
*
***********************************************************************/
int LER_ObterNumLinhas( void ) ;
/***********************************************************************
*
* $FC Função: LER &Abrir arquivo script de teste
*
* $ED Descrição da função
* Abre o arquivo que contém o script de teste.
* A extensão default do arquivo de comandos script de teste é
* ".script" e será acrescida ao nome do arquivo caso este não
* contenha nome de extensão.
*
* $EP Parâmetros
* $P NomeArqParm - nome do arquivo contendo o script de teste
*
* $FV Valor retornado
* LER_CondRetOK - caso tenha sido possível abrir o arquivo.
* LER_CondRetNaoAbriu - caso tenha ocorrido algum erro.
* Não há discriminação do erro encontrado.
*
***********************************************************************/
LER_tpCondRet LER_AbrirArquivoScript( char * NomeArqParm ) ;
/***********************************************************************
*
* $FC Função: LER &Ler linha script eliminando brancos ao final
*
* $ED Descrição da função
* Lê uma linha do arquivo script e elimina os caracteres branco,
* fim de linha, tabulação etc. do final da linha lida.
*
* $FV Valor retornado
* Retorna o tamanho da linha lida.
* Será:
* -1 caso tenha ocorrido fim de arquivo.
* -2 caso tenha ocorrido algum problema de leitura.
*
***********************************************************************/
int LER_LerLinhaScript( void ) ;
/***********************************************************************
*
* $FC Função: LER &Interpretar comandos de teste
*
* $ED Descrição da função
* Interpreta os comandos de teste disponibilizados pelo módulo
* de leitura.
*
* Ver a descrição do módulo para mais detalhes
*
* $EP Parâmetros
* $P - Comando de teste a ser interpretado
*
* $FV Valor retornado
* TST_CondRetOK - caso tenha interpretado corretamente
* TST_CondRetNaoExecutou - caso o comando de teste a interpretar
* não pertença ao conjunto de LER
* TST_CondRetErro - caso o comando de teste é do conjunto de LER
* e está sintaticamente errado.
* Neste caso é gerada uma mensagem de erro no
* log.
*
***********************************************************************/
TST_tpCondRet LER_InterpretarComandos( char * ComandoTeste ) ;
/***********************************************************************
*
* $FC Função: LER &Declarar parâmetro simbólico
*
* $EP Parâmetros
* Interpreta uma linha de comando de teste contendo uma declaração de
* nome simbólico.
* Todas as declarações têm o formato:
* =declararparm <nome> <tipo> <literal>
* em que o <literal> deve estar consistente com o <tipo>
* São geradas mensagens de erro no log de teste caso a declaração
* não possa ser realizada.
*
* $FV Valor retornado
* TRUE - se a declaração ocorreu
* FALSE - caso contrário
*
***********************************************************************/
int LER_DeclararParametro( void ) ;
/***********************************************************************
*
* $FC Função: LER &Exibir declaração de símbolo
*
* $ED Descrição da função
* Exibe o Símbolo e o valor associado ao símbolo, sendo que este
* é exibido em hexadecimal.
*
***********************************************************************/
void LER_ExibirParametro( char * Simbolo ) ;
/***********************************************************************
*
* $FC Função: LER &Ler linha de parâmetros
*
* $ED Descrição da função
* Lê um número variável de parâmetros
*
* $EP Parâmetros
* $P Tipos é um string contendo a identificação dos tipos dos parâmetros
* a serem lidos.
* $P ... Os demais parâmetros são referências (ponteiros) para os
* espaços onde deverão ser armazenados os valores lidos.
*
* Tal como em scanf deve-se tomar o cuidado de assegurar que a lista
* de referência e o string de tipos tenha o mesmo tamanho
* e que os indicadores de tipo sejam consistentes com a referência
* posicionalmente correspondentes.
*
* Ao ler um campo, primeiro procura-se ler um nome de parâmetro já
* declarado. Caso isto seja possível e o tipo esteja correto
* é "lido" o valor contido no parâmetro.
* Caso não seja possível, tenta ler um literal em acordo com o tipo
* dado.
*
* Gera mensagens de erro para parâmetros desconhecidos, sintaxe errada
* e tipo inconsistente com o solicitado no correspondente caractere no
* string Tipos.
*
* $FV Valor retornado
* Retorna o número de campos lidos até concluir ou até encontrar
* um erro.
*
***********************************************************************/
int LER_LerParametros( char * Tipos , ... ) ;
/***********************************************************************
*
* $FC Função: LER &Ler parâmetro caractere
*
* $EP Parâmetros
* $P Parm é um ponteiro para um caractere que receberá o valor lido
*
* $FV Valor retornado
* TRUE - se leu
* FALSE - se ocorreu algum erro
*
* $FGP Tipos e Variáveis globais externas do próprio módulo
* inxBuffer - é avançado para o primeiro caractere branco imediatamente
* a seguir do caractere lido
*
* $EIU Interface com usuário pessoa
* Um caractere deve vir entre aspas simples. Valem os caracteres de controle
* \n \r \t \a \v \f \\ \' \" \? e \0
* São geradas mensagens de erro no log
*
***********************************************************************/
int LER_LerParmChar( char * Parm ) ;
/***********************************************************************
*
* $FC Função: LER &Ler parâmetro inteiro
*
* $EP Parâmetros
* $P Parm é um ponteiro para um int que receberá o valor lido
*
* $FV Valor retornado
* TRUE - se leu
* FALSE - se ocorreu algum erro
*
* $FGP Tipos e Variáveis globais externas do próprio módulo
* inxBuffer - é avançado para o primeiro caractere branco imediatamente
* a seguir do int lido
*
* $EIU Interface com usuário pessoa
* São geradas mensagens de erro no log
*
***********************************************************************/
int LER_LerParmInt( int * Parm ) ;
/***********************************************************************
*
* $FC Função: LER &Ler parâmetro flutuante
*
* $EP Parâmetros
* $P Parm é um ponteiro para um double que receberá o valor lido
*
* $FV Valor retornado
* TRUE - se leu
* FALSE - se ocorreu algum erro
*
* $FGP Tipos e Variáveis globais externas do próprio módulo
* inxBuffer - é avançado para o primeiro caractere branco imediatamente
* a seguir do double lido
*
* $EIU Interface com usuário pessoa
* São válidas todas as formas de literal double aceitas pelo scanf.
* São geradas mensagens de erro no log
*
***********************************************************************/
int LER_LerParmDouble( double * Parm ) ;
/***********************************************************************
*
* $FC Função: LER &Ler parâmetro nome
*
* $EP Parâmetros
* $P Parm é um ponteiro para um caractere que receberá o nome lido
* $P tamString é o tamanho do nome que foi lido
* $P dimString é o tamanho máximo que o nome poderá ter, já
* descontado o zero final
*
* $FV Valor retornado
* TRUE - se leu
* FALSE - se ocorreu algum erro
*
* $FGP Tipos e Variáveis globais externas do próprio módulo
* inxBuffer - é avançado para o primeiro caractere branco imediatamente
* a seguir do nome lido
*
* $EIU Interface com usuário pessoa
* São válidas as mesmas regras de nomes C.
* São geradas mensagens de erro no log
*
***********************************************************************/
int LER_LerParmNome( char * Parm , int * tamNome , int dimNome ) ;
/***********************************************************************
*
* $FC Função: LER &Ler parâmetro string
*
* $EP Parâmetros
* $P Parm é um ponteiro para um caractere que receberá o string lido
* $P tamString é o tamanho do string que foi lido
* $P dimString é o tamanho máximo que o string poderá ter, já
* descontado o zero final
*
* $FV Valor retornado
* TRUE - se leu
* FALSE - se ocorreu algum erro
*
* $FGP Tipos e Variáveis globais externas do próprio módulo
* inxBuffer - é avançado para o primeiro caractere branco imediatamente
* a seguir do string lido
*
* $EIU Interface com usuário pessoa
* Um string deve vir entre aspas duplas.
* Um string pode conter caracteres de controle
* \n \r \t \a \v \f \\ \' \" \? e \0
*
* São geradas mensagens de erro no log
*
***********************************************************************/
int LER_LerParmString( char * Parm , int * tamString , int dimString ) ;
/***********************************************************************
*
* $FC Função: LER &Pular comando de teste
*
* $ED Descrição da função
* Avança o cursor do buffer de leitura por cima de um comando de teste.
* Todos os comandos de teste principiam com o prefixo '='
*
***********************************************************************/
void LER_PularComando( void ) ;
#undef LerParm_EXT
/********** Fim do módulo de definição: LER Ler parâmetros de comandos **********/
#else
#endif