module: c-parse author: Robert Stockton (rgs@cs.cmu.edu) copyright: see below This code was produced by the Gwydion Project at Carnegie Mellon University. If you are interested in using this code, contact "Scott.Fahlman@cs.cmu.edu" (Internet). //====================================================================== // // Copyright (c) 1994 Carnegie Mellon University // Copyright (c) 1998, 1999, 2000 Gwydion Dylan Maintainers // All rights reserved. // //====================================================================== //====================================================================== // Module c-parse handles parsing of native C header files. Theoretically, we // could have arbitrary C code in these files. However, in practice we only // need to be able to parse about half of the C language. // // The actual "source" for the c parser is contained in "c-parse.input", which // is an input file for parsergen. // "C-parse.dylan" is the pure Dylan output of this generator, and should // *not* be considered human readable code. // // The "parse-tree" is a very ad-hoc structure, because it is intended to be // quite ephemeral. The final goal is to add an ordered sequence of // s to the which both controls the parsing process // and returns the results of the parse. This approach allows us to do a // single pass parse of the data, and also support the feedback required to // handle C's "type names", which are context sensitive. // // The token stream provided by the tokenizer may actually correspond to // several different "included" files. We can detect transitions into and out // of recursively included files by watching for and // . We make the simplifying assumption that declarations // will not be split across include files. This assumption should be // justifiable on the basis that any exception would be unbearably ugly. // // The raw parse engine has been fitted with a number of different front ends // to allow several different types of data to be parsed. The following // functions are exported: // parse(filename, #key defines, undefines) => result :: // This function processes an entire include file, leaving a series of // declarations in the returned parse state. // parse-type(alien-name :: , old-state :: ) // => result :: // This function parses the contents of the given string and tries to // interpret it as the name of an object or type declared in "old-state". // Parse-type will signal an error if no such declaration is found. // parse-macro(cpp-name :: , old-state :: ) // => result :: constant-value or // This function tries to evaluate a preprocessor constant in hopes that // it will either evaluate to a type or object name or to a constant // compile time value. It returns the matched declaration or value, or it // signals an error. // cpp-parse(tokenizer :: ) => result :: // This function evaluates a line of CPP input according to a limited set // of C operators and an odd set of evaluation rules which make undefined // identifiers into integers. (Note that this function is used by the // tokenizer, but also recursively uses the tokenizer by specifying a few // magic keywords to avoid infinite recursion.) This function consumes // one line's worth of tokens from the tokenizer and then leaves it in a // consistent state for further processing by a different parser. // // The input file is messier than it might be, because we have retained // productions corresponding to the entire C language -- simply commenting out // the ones which are not needed for header files. This should simplify // future expansion. //====================================================================== //---------------------------------------------------------------------- // Simple parser support //---------------------------------------------------------------------- // *HACK*: We temporarily use a global variable to figure out whether a given // declaration is an object declaration or a typedef declaration. This // appears to be simpler than trying to propogate detailed information // upwards. // define variable *typedef-flag* = #f; // This function checks to see whether the given object can be interpreted as // an integer. If so, it returns the integer value. Otherwise, it raises an // error. This function is used to evaluate compile time constants. // define generic int-value (value ::