Statement* Parser::readStatement()
{
Statement* statement;
if(currentToken.id == Token::string && currentToken.value == "if")
{
nextToken();
IfStatement* ifStatement = new IfStatement(*includeFile);
ifStatement->condition = readExpression();
ifStatement->thenStatements = readStatements();
if(currentToken.id == Token::string && currentToken.value == "else")
{
nextToken();
ifStatement->elseStatements = readStatements();
}
statement = ifStatement;
}
else if(currentToken.id == Token::string && currentToken.value == "include")
{
nextToken();
String fileName;
readString(fileName);
if(!File::isPathAbsolute(fileName))
{
String parentDir = includeFile->fileDir;
if(parentDir != ".")
fileName = parentDir + "/" + fileName;
}
Parser parser(engine);
WrapperStatement* statement = new WrapperStatement(*includeFile);
statement->statement = parser.parse(fileName, errorHandler, errorHandlerUserData);
if(!statement->statement)
throw false;
return statement;
}
else
statement = readAssignment();
while(currentToken.id == Token::comma)
nextToken();
return statement;
}
int
main (int argc, char *argv[])
{
static const struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"version", no_argument, 0, 'v'},
{"check", no_argument, 0, 'c'},
{"output", required_argument, 0, 'o'},
{0, 0, 0, 0}
};
int option_index = 0;
int option_result;
char *outputFileName = NULL;
char *inputFileAsnName = NULL;
char *inputFileAssignmentName = NULL;
int checkSyntaxOnly = 0;
asn1_node definitions = NULL;
asn1_node structure = NULL;
char errorDescription[ASN1_MAX_ERROR_DESCRIPTION_SIZE];
int asn1_result = ASN1_SUCCESS;
FILE *outputFile;
FILE *inputFile;
char varName[1024];
char value[1024];
unsigned char *der = NULL;
int der_len;
int k;
int last_ra;
set_program_name (argv[0]);
opterr = 0; /* disable error messages from getopt */
while (1)
{
option_result =
getopt_long (argc, argv, "hvco:", long_options, &option_index);
if (option_result == -1)
break;
switch (option_result)
{
case 'h': /* HELP */
free (outputFileName);
usage (EXIT_SUCCESS);
break;
case 'v': /* VERSION */
version_etc (stdout, program_name, PACKAGE, VERSION,
"Fabio Fiorina", NULL);
free (outputFileName);
exit (0);
break;
case 'c': /* CHECK SYNTAX */
checkSyntaxOnly = 1;
break;
case 'o': /* OUTPUT */
outputFileName = (char *) malloc (strlen (optarg) + 1);
strcpy (outputFileName, optarg);
break;
case '?': /* UNKNOW OPTION */
free (outputFileName);
fprintf (stderr,
"asn1Coding: option '%s' not recognized or without argument.\n\n",
argv[optind - 1]);
usage (EXIT_FAILURE);
break;
default:
fprintf (stderr,
"asn1Coding: ?? getopt returned character code Ox%x ??\n",
option_result);
}
}
if (optind == argc || optind == argc - 1)
{
free (outputFileName);
fputs ("asn1Coding: input files missing\n", stderr);
usage (EXIT_FAILURE);
}
inputFileAsnName = (char *) malloc (strlen (argv[optind]) + 1);
strcpy (inputFileAsnName, argv[optind]);
inputFileAssignmentName = (char *) malloc (strlen (argv[optind + 1]) + 1);
strcpy (inputFileAssignmentName, argv[optind + 1]);
asn1_result =
asn1_parser2tree (inputFileAsnName, &definitions, errorDescription);
switch (asn1_result)
{
case ASN1_SUCCESS:
fputs ("Parse: done.\n", stderr);
break;
case ASN1_FILE_NOT_FOUND:
fprintf (stderr, "asn1Coding: FILE %s NOT FOUND\n", inputFileAsnName);
break;
case ASN1_SYNTAX_ERROR:
case ASN1_IDENTIFIER_NOT_FOUND:
case ASN1_NAME_TOO_LONG:
fprintf (stderr, "asn1Coding: %s\n", errorDescription);
break;
default:
fprintf (stderr, "libtasn1 ERROR: %s\n", asn1_strerror (asn1_result));
}
if (asn1_result != ASN1_SUCCESS)
{
free (inputFileAsnName);
free (inputFileAssignmentName);
exit (1);
}
inputFile = fopen (inputFileAssignmentName, "r");
if (inputFile == NULL)
{
fprintf (stderr, "asn1Coding: file '%s' not found\n",
inputFileAssignmentName);
free (inputFileAsnName);
free (inputFileAssignmentName);
exit (1);
}
putc ('\n', stderr);
while ((last_ra = readAssignment (inputFile, varName, value))
== ASSIGNMENT_SUCCESS)
{
fprintf (stderr, "var=%s, value=%s\n", varName, value);
if (structure == NULL)
{
asn1_result = asn1_create_element (definitions, value, &structure);
}
else
{
if (strcmp(value, "(NULL)") == 0)
asn1_result = asn1_write_value (structure, varName, NULL, 0);
else
asn1_result = asn1_write_value (structure, varName, value, 0);
}
if (asn1_result != ASN1_SUCCESS)
{
fprintf (stderr, "libtasn1 ERROR: %s\n",
asn1_strerror (asn1_result));
asn1_delete_structure (&definitions);
asn1_delete_structure (&structure);
free (inputFileAsnName);
free (inputFileAssignmentName);
fclose (inputFile);
exit (1);
}
}
if (last_ra != ASSIGNMENT_EOF)
{
fprintf (stderr, "asn1Coding: error reading assignment file\n");
exit (1);
}
fclose (inputFile);
putc ('\n', stderr);
asn1_print_structure (stderr, structure, "", ASN1_PRINT_NAME_TYPE_VALUE);
der_len = 0;
asn1_result = asn1_der_coding (structure, "", der, &der_len,
errorDescription);
if (asn1_result == ASN1_MEM_ERROR)
{
der = malloc (der_len);
asn1_result = asn1_der_coding (structure, "", der, &der_len,
errorDescription);
}
fprintf (stderr, "\nCoding: %s\n\n", asn1_strerror (asn1_result));
if (asn1_result != ASN1_SUCCESS)
{
fprintf (stderr, "asn1Coding: %s\n", errorDescription);
free (der);
asn1_delete_structure (&definitions);
asn1_delete_structure (&structure);
free (inputFileAsnName);
free (inputFileAssignmentName);
exit (1);
}
/* Print the 'Certificate1' DER encoding */
fprintf (stderr, "-----------------\nNumber of bytes=%i\n", der_len);
for (k = 0; k < der_len; k++)
fprintf (stderr, "%02x ", der[k]);
fputs ("\n-----------------\n", stderr);
asn1_delete_structure (&definitions);
asn1_delete_structure (&structure);
if (!checkSyntaxOnly)
{
if (outputFileName == NULL)
createFileName (inputFileAssignmentName, &outputFileName);
fprintf (stderr, "\nOutputFile=%s\n", outputFileName);
outputFile = fopen (outputFileName, "w");
if (outputFile == NULL)
{
fprintf (stderr,
"asn1Coding: output file '%s' not available\n",
outputFileName);
free (der);
free (inputFileAsnName);
free (inputFileAssignmentName);
free (outputFileName);
exit (1);
}
for (k = 0; k < der_len; k++)
fprintf (outputFile, "%c", der[k]);
fclose (outputFile);
fputs ("\nWriting: done.\n", stderr);
}
free (der);
free (inputFileAsnName);
free (inputFileAssignmentName);
free (outputFileName);
exit (0);
}
// takes a void pointer to the data as output from write_data and a readReturn struct to put the array and its type in.
int read_data(void* array, readReturn* ret){
if(!ret || !array)
return P_NULL_PTR;
switch( (char) ((char*)array)[0] ) {
case P_ROBOT_INIT:
{
robotInit* arr;
int count = readRobotInit(array, arr);
// Create a readReturn if we have a NULL pointer
//if (!ret)
// ret = new readReturn
ret->array = (void*)arr;
ret->size = count;
ret->type = P_ROBOT_INIT;
return count;
}
case P_ROBOT_UPDATE:
{
robotUpdate* arr;
int count =readRobotUpdate(array, arr);
ret->array = (void*)arr;
ret->size = count;
ret->type = P_ROBOT_UPDATE;
return count;
}
break;
case P_OBJECT:
{
object* arr;
int count =readObject(array, arr);
ret->array = (void*)arr;
ret->size = count;
ret->type = P_OBJECT;
return count;
}
break;
case P_ASSIGNMENT:
{
assignment* arr;
int count = readAssignment(array, arr);
ret->array = (void*)arr;
ret->size = count;
ret->type = P_ASSIGNMENT;
return count;
}
case P_COMMAND:
{
command* arr;
int count = readCommand(array, arr);
ret->array = (void*)arr;
ret->size = count;
ret->type = P_COMMAND;
return count;
}
case P_ROBOT_RM:
{
robotRm* arr;
int count = readRobotRm(array, arr);
ret->array = (void*)arr;
ret->size = count;
ret->type = P_ROBOT_RM;
return count;
}
default:
std::cerr << "Attempt to read unknown type: " << std::hex << (char) ((char*)array)[0] << "\n";
}
return P_INVD_TYPE;
}
