--- /dev/null
+-I. -DHAVE_CONFIG_H -D_GNU_SOURCE
+
+#+partial
++forcehints
+
+-warnposix
+
++unixlib
+
+-unrecogcomments # XXX ignore doxygen markings
+
++strict # lclint level
+
+# --- in progress
+-branchstate
+-bufferoverflowhigh
+-compdef
+-dependenttrans
+-evalorder
+-exitarg
+-exportheadervar
+-exportlocal
+-fcnuse
+-formatconst
+-globs
+-globstate
+-ifempty
+-infloopsuncon
+-internalglobs
+-mods
+-noeffect
+-noeffectuncon
+-nullpass
+-nullret
+-nullstate
+-paramuse
+-readonlytrans
+-retalias
+-retvalint
+-shiftimplementation
+-shiftnegative
+-sizeoftype
+-temptrans
+-unqualifiedtrans
+-usereleased
+
+# --- +partial artifacts
+
+# --- not-yet at strict level
+-bitwisesigned #
+-elseifcomplete #
+-exportconst #
+-exportfcn #
+-exporttype #
+-exportvar #
+-fielduse #
+-forblock # tedious
+-ifblock # tedious
+-namechecks # tedious ANSI compliance checks
+-ptrarith #
+
+-compdestroy #
+-mustdefine #
+-sys-dir-errors
+
+-strictops #
+-whileblock # tedious
+
+# --- not-yet at checks level
++enumint #
+-mustfree #
+-predboolptr #
+-usedef #
+
+# --- not-yet at standard level
+-boolops #
++boolint #
++charint #
++ignorequals #
++matchanyintegral #
* c1 and c2 are (optional) integer parameters for the message.\r
* Terminates iff level==ERROR, otherwise returns.\r
*/\r
-void ErrorMessage(level,msg,c1,c2)\r
-int level; \r
-char *msg;\r
-int c1, c2;\r
+void ErrorMessage(int level, const char *msg, int c1, int c2)\r
{\r
fflush(stdout);\r
printf("\n*** ");\r
/* initializeMemory()\r
* take care of memory initialization \r
*/\r
-void initializeMemory()\r
+void initializeMemory(void)\r
{ ; } /* nothing in this implementation -- use malloc */\r
\r
/* sexpAlloc(n)\r
* Allocates n bytes of storage. \r
* Terminates execution if no memory available.\r
*/\r
-char *sexpAlloc(n)\r
-int n;\r
+char *sexpAlloc(int n)\r
{ char *c = (char *)malloc((unsigned int) n);\r
if (c == NULL) ErrorMessage(ERROR,"Error in sexpAlloc: out of memory!",0,0);\r
return(c);\r
* Creates and initializes new sexpSimpleString object.\r
* Allocates 16-character buffer to hold string.\r
*/\r
-sexpSimpleString *newSimpleString()\r
+sexpSimpleString *newSimpleString(void)\r
{\r
sexpSimpleString *ss;\r
ss = (sexpSimpleString *) sexpAlloc(sizeof(sexpSimpleString));\r
/* simpleStringLength(ss)\r
* returns length of simple string \r
*/\r
-long int simpleStringLength(ss)\r
-sexpSimpleString *ss;\r
+long int simpleStringLength(sexpSimpleString *ss)\r
{ return(ss->length); }\r
\r
/* simpleStringString(ss)\r
* returns pointer to character array of simple string \r
*/\r
-octet *simpleStringString(ss)\r
-sexpSimpleString *ss;\r
+octet *simpleStringString(sexpSimpleString *ss)\r
{ return(ss->string); }\r
\r
/* reallocateSimpleString(ss)\r
* Changes space allocated to ss.\r
* Space allocated is set to roughly 3/2 the current string length, plus 16.\r
*/\r
-sexpSimpleString *reallocateSimpleString(ss)\r
-sexpSimpleString *ss;\r
+sexpSimpleString *reallocateSimpleString(sexpSimpleString *ss)\r
{\r
int newsize, i;\r
octet *newstring;\r
* Appends the character c to the end of simple string ss.\r
* Reallocates storage assigned to s if necessary to make room for c.\r
*/\r
-void appendCharToSimpleString(c,ss)\r
-int c;\r
-sexpSimpleString *ss;\r
+void appendCharToSimpleString(int c, sexpSimpleString *ss)\r
{\r
if (ss==NULL) ss = newSimpleString();\r
if (ss->string == NULL || ss->length == ss->allocatedLength )\r
* Creates and initializes a new sexpString object.\r
* Both the presentation hint and the string are initialized to NULL.\r
*/\r
-sexpString *newSexpString()\r
+sexpString *newSexpString(void)\r
{\r
sexpString *s;\r
s = (sexpString *) sexpAlloc(sizeof(sexpString));\r
/* sexpStringPresentationHint()\r
* returns presentation hint field of the string \r
*/\r
-sexpSimpleString *sexpStringPresentationHint(s)\r
-sexpString *s;\r
+sexpSimpleString *sexpStringPresentationHint(sexpString *s)\r
{ return(s->presentationHint); }\r
\r
/* setSexpStringPresentationHint()\r
* assigns the presentation hint field of the string\r
*/\r
-void setSexpStringPresentationHint(s,ss)\r
-sexpString *s;\r
-sexpSimpleString *ss;\r
+void setSexpStringPresentationHint(sexpString *s, sexpSimpleString *ss)\r
{ s->presentationHint = ss; }\r
\r
/* setSexpStringString()\r
* assigns the string field of the string\r
*/\r
-void setSexpStringString(s,ss)\r
-sexpString *s;\r
-sexpSimpleString *ss;\r
+void setSexpStringString(sexpString *s, sexpSimpleString *ss)\r
{ s->string = ss; }\r
\r
/* sexpStringString()\r
* returns the string field of the string\r
*/\r
-sexpSimpleString *sexpStringString(s)\r
-sexpString *s;\r
+sexpSimpleString *sexpStringString(sexpString *s)\r
{ return(s->string); }\r
\r
/* closeSexpString()\r
* finish up string computations after created \r
*/\r
-void closeSexpString(s)\r
-sexpString *s;\r
+void closeSexpString(sexpString *s)\r
{ ; } /* do nothing in this implementation */\r
\r
/**************************/\r
* Both the first and rest fields are initialized to NULL, which is\r
* SEXP's representation of an empty list.\r
*/\r
-sexpList *newSexpList()\r
+sexpList *newSexpList(void)\r
{\r
sexpList *list;\r
list = (sexpList *) sexpAlloc(sizeof(sexpList));\r
/* sexpAddSexpListObject()\r
* add object to end of list\r
*/\r
-void sexpAddSexpListObject(list,object)\r
-sexpList *list;\r
-sexpObject *object;\r
+void sexpAddSexpListObject(sexpList *list, sexpObject *object)\r
{\r
if (list->first == NULL)\r
list->first = object;\r
/* closeSexpList()\r
* finish off a list that has just been input\r
*/\r
-void closeSexpList(list)\r
-sexpList *list;\r
+void closeSexpList(sexpList *list)\r
{ ; } /* nothing in this implementation */\r
\r
/* Iteration on lists.\r
/* sexpListIter()\r
* return the iterator for going over a list \r
*/\r
-sexpIter *sexpListIter(list)\r
-sexpList *list;\r
+sexpIter *sexpListIter(sexpList *list)\r
{ return((sexpIter *)list); }\r
\r
/* sexpIterNext()\r
* advance iterator to next element of list, or else return null\r
*/\r
-sexpIter *sexpIterNext(iter)\r
-sexpIter *iter;\r
+sexpIter *sexpIterNext(sexpIter *iter)\r
{ if (iter == NULL) return(NULL);\r
return((sexpIter *)(((sexpList *)iter)->rest));\r
}\r
/* sexpIterObject ()\r
* return object corresponding to current state of iterator\r
*/\r
-sexpObject *sexpIterObject(iter)\r
-sexpIter *iter;\r
+sexpObject *sexpIterObject(sexpIter *iter)\r
{ if (iter == NULL) return(NULL);\r
return(((sexpList *)iter)->first);\r
}\r
/* SEXP OBJECT MANIPULATION */\r
/****************************/\r
\r
-int isObjectString(object)\r
-sexpObject *object;\r
+int isObjectString(sexpObject *object)\r
{ if (((sexpString *)object)->type == SEXP_STRING) return(TRUE);\r
else return(FALSE);\r
}\r
\r
-int isObjectList(object)\r
-sexpObject *object;\r
+int isObjectList(sexpObject *object)\r
{ if (((sexpList *)object)->type == SEXP_LIST) return(TRUE);\r
else return(FALSE);\r
}\r
-\r
/* initializeCharacterTables\r
* initializes all of the above arrays\r
*/ \r
-void initializeCharacterTables()\r
+void initializeCharacterTables(void)\r
{ int i;\r
for (i=0;i<256;i++) upper[i] = i;\r
for (i='a'; i<='z'; i++) upper[i] = i - 'a' + 'A';\r
/* isWhiteSpace(c)\r
* Returns TRUE if c is a whitespace character (space, tab, etc. ).\r
*/\r
-int isWhiteSpace(c)\r
-int c;\r
+int isWhiteSpace(int c)\r
{ return ((c>=0 && c<=255) && whitespace[c]); }\r
\r
/* isDecDigit(c)\r
* Returns TRUE if c is a decimal digit.\r
*/\r
-int isDecDigit(c)\r
-int c;\r
+int isDecDigit(int c)\r
{ return ((c>=0 && c<=255) && decdigit[c]); }\r
\r
/* isHexDigit(c)\r
* Returns TRUE if c is a hexadecimal digit.\r
*/\r
-int isHexDigit(c)\r
-int c;\r
+int isHexDigit(int c)\r
{ return ((c>=0 && c<=255) && hexdigit[c]); }\r
\r
/* isBase64Digit(c)\r
* returns TRUE if c is a base64 digit A-Z,a-Z,0-9,+,/\r
*/\r
-int isBase64Digit(c)\r
-int c;\r
+int isBase64Digit(int c)\r
{ return ((c>=0 && c<=255) && base64digit[c]); }\r
\r
/* isTokenChar(c)\r
* Returns TRUE if c is allowed in a token\r
*/\r
-int isTokenChar(c)\r
-int c;\r
+int isTokenChar(int c)\r
{ return ((c>=0 && c<=255) && tokenchar[c]); }\r
\r
/* isAlpha(c)\r
* Returns TRUE if c is alphabetic\r
*/\r
-int isAlpha(c)\r
-int c;\r
+int isAlpha(int c)\r
{ return ((c>=0 && c<=255) && alpha[c]); }\r
\r
/**********************/\r
\r
/* changeInputByteSize(is,newByteSize)\r
*/\r
-void changeInputByteSize(is,newByteSize)\r
-sexpInputStream *is;\r
-int newByteSize;\r
+void changeInputByteSize(sexpInputStream *is, int newByteSize)\r
{\r
is->byteSize = newByteSize;\r
is->nBits = 0;\r
* The value EOF is obtained when no more input is available. \r
* This code handles 4-bit/6-bit/8-bit channels.\r
*/\r
-void getChar(is)\r
-sexpInputStream *is;\r
+void getChar(sexpInputStream *is)\r
{ int c;\r
if (is->nextChar == EOF) \r
{ is->byteSize = 8;\r
* (Prefixes stream with one blank, and initializes stream\r
* so that it reads from standard input.)\r
*/\r
-sexpInputStream *newSexpInputStream()\r
+sexpInputStream *newSexpInputStream(void)\r
{\r
sexpInputStream *is;\r
is = (sexpInputStream *) sexpAlloc(sizeof(sexpInputStream));\r
/* skipWhiteSpace(is)\r
* Skip over any white space on the given sexpInputStream.\r
*/\r
-void skipWhiteSpace(is)\r
-sexpInputStream *is;\r
+void skipWhiteSpace(sexpInputStream *is)\r
{\r
while (isWhiteSpace(is->nextChar)) is->getChar(is);\r
} \r
* Skip the following input character on input stream is, if it is\r
* equal to the character c. If it is not equal, then an error occurs.\r
*/\r
-void skipChar(is,c)\r
-sexpInputStream *is;\r
-int c;\r
+void skipChar(sexpInputStream *is, int c)\r
{\r
if (is->nextChar==c) \r
is->getChar(is);\r
/* scanToken(is,ss)\r
* scan one or more characters into simple string ss as a token.\r
*/\r
-void scanToken(is,ss)\r
-sexpInputStream *is;\r
-sexpSimpleString *ss;\r
+void scanToken(sexpInputStream *is, sexpSimpleString *ss)\r
{\r
skipWhiteSpace(is);\r
while (isTokenChar(is->nextChar))\r
* scan one or more characters (until EOF reached)\r
* return an object that is just that string\r
*/\r
-sexpObject *scanToEOF(is)\r
-sexpInputStream *is;\r
+sexpObject *scanToEOF(sexpInputStream *is)\r
{\r
sexpSimpleString *ss = newSimpleString();\r
sexpString *s = newSexpString();\r
/* scanDecimal(is)\r
* returns long integer that is value of decimal number\r
*/\r
-unsigned long int scanDecimal(is)\r
-sexpInputStream *is;\r
+unsigned long int scanDecimal(sexpInputStream *is)\r
{ unsigned long int value = 0L;\r
int i = 0;\r
while (isDecDigit(is->nextChar)) \r
/* scanVerbatimString(is,ss,length)\r
* Reads verbatim string of given length into simple string ss.\r
*/\r
-void scanVerbatimString(is,ss,length)\r
-sexpInputStream *is;\r
-sexpSimpleString *ss;\r
-long int length;\r
+void scanVerbatimString(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
{\r
long int i = 0L;\r
skipWhiteSpace(is);\r
* Handles ordinary C escapes. \r
* If of indefinite length, length is -1.\r
*/\r
-void scanQuotedString(is,ss,length)\r
-sexpInputStream *is;\r
-sexpSimpleString *ss;\r
-long int length;\r
+void scanQuotedString(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
{\r
int c;\r
skipChar(is,'"');\r
* Reads hexadecimal string into simple string ss.\r
* String is of given length result, or length = -1 if indefinite length.\r
*/\r
-void scanHexString(is,ss,length)\r
-sexpInputStream *is;\r
-sexpSimpleString *ss;\r
-long int length;\r
+void scanHexString(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
{ changeInputByteSize(is,4);\r
skipChar(is,'#');\r
while (is->nextChar != EOF && (is->nextChar != '#' || is->byteSize==4))\r
* Reads base64 string into simple string ss.\r
* String is of given length result, or length = -1 if indefinite length.\r
*/\r
-void scanBase64String(is,ss,length)\r
-sexpInputStream *is;\r
-sexpSimpleString *ss;\r
-long int length;\r
+void scanBase64String(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
{ changeInputByteSize(is,6);\r
skipChar(is,'|');\r
while (is->nextChar != EOF && (is->nextChar != '|' || is->byteSize == 6))\r
* Determines type of simple string from the initial character, and\r
* dispatches to appropriate routine based on that. \r
*/\r
-sexpSimpleString *scanSimpleString(is)\r
-sexpInputStream *is;\r
+sexpSimpleString *scanSimpleString(sexpInputStream *is)\r
{\r
long int length;\r
sexpSimpleString *ss;\r
/* scanString(is)\r
* Reads and returns a string [presentationhint]string from input stream.\r
*/\r
-sexpString *scanString(is)\r
-sexpInputStream *is;\r
+sexpString *scanString(sexpInputStream *is)\r
{\r
sexpString *s;\r
sexpSimpleString *ss;\r
/* scanList(is)\r
* Read and return a sexpList from the input stream.\r
*/\r
-sexpList *scanList(is)\r
-sexpInputStream *is;\r
+sexpList *scanList(sexpInputStream *is)\r
{ sexpList *list;\r
sexpObject *object;\r
skipChar(is,'(');\r
/* scanObject(is)\r
* Reads and returns a sexpObject from the given input stream.\r
*/\r
-sexpObject *scanObject(is)\r
-sexpInputStream *is;\r
+sexpObject *scanObject(sexpInputStream *is)\r
{\r
sexpObject *object;\r
skipWhiteSpace(is);\r
/*************************************************************************/\r
/* main(argc,argv)\r
*/\r
-int main(argc,argv)\r
-int argc;\r
-char **argv;\r
+int main(int argc, char **argv)\r
{ char *c;\r
int swa = TRUE;\r
int swb = TRUE;\r
* Puts the character c out on the output stream os.\r
* Keeps track of the "column" the next output char will go to.\r
*/\r
-void putChar(os,c)\r
-sexpOutputStream *os;\r
-int c;\r
+void putChar(sexpOutputStream *os, int c)\r
{\r
putc(c,os->outputFile);\r
os->column++;\r
/* varPutChar(os,c)\r
* putChar with variable sized output bytes considered.\r
*/\r
-void varPutChar(os,c)\r
-sexpOutputStream *os;\r
-int c; /* this is always an eight-bit byte being output */\r
+void varPutChar(sexpOutputStream *os, int c)\r
{\r
c &= 0xFF;\r
os->bits = (os->bits << 8) | c;\r
* Change os->byteSize to newByteSize\r
* record mode in output stream for automatic line breaks\r
*/\r
-void changeOutputByteSize(os,newByteSize,mode)\r
-sexpOutputStream *os;\r
-int newByteSize;\r
-int mode;\r
+void changeOutputByteSize(sexpOutputStream *os, int newByteSize, int mode)\r
{ \r
if (newByteSize != 4 && newByteSize !=6 && newByteSize !=8)\r
ErrorMessage(ERROR,"Illegal output base %d.",newByteSize,0);\r
/* flushOutput(os)\r
* flush out any remaining bits \r
*/\r
-void flushOutput(os)\r
-sexpOutputStream *os;\r
+void flushOutput(sexpOutputStream * os)\r
{ if (os->nBits > 0)\r
{ \r
if (os->byteSize == 4)\r
* indentation level (but never indents more than half of maxcolumn).\r
* Resets column for next output character.\r
*/\r
-void newLine(os,mode)\r
-sexpOutputStream *os;\r
-int mode;\r
+void newLine(sexpOutputStream *os, int mode)\r
{ int i;\r
if (mode == ADVANCED || mode == BASE64)\r
{ os->putChar(os,'\n');\r
/* newSexpOutputStream()\r
* Creates and initializes new sexpOutputStream object.\r
*/\r
-sexpOutputStream *newSexpOutputStream()\r
+sexpOutputStream *newSexpOutputStream(void)\r
{\r
sexpOutputStream *os;\r
os = (sexpOutputStream *) sexpAlloc(sizeof(sexpOutputStream));\r
/* printDecimal(os,n)\r
* print out n in decimal to output stream os\r
*/\r
-void printDecimal(os,n)\r
-sexpOutputStream *os;\r
-long int n;\r
+void printDecimal(sexpOutputStream *os, long int n)\r
{ char buffer[50];\r
int i;\r
sprintf(buffer,"%ld",n);\r
/* canonicalPrintVerbatimSimpleString(os,ss)\r
* Print out simple string ss on output stream os as verbatim string.\r
*/\r
-void canonicalPrintVerbatimSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void canonicalPrintVerbatimSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{ \r
long int len;\r
long int i;\r
/* canonicalPrintString(os,s)\r
* Prints out sexp string s onto output stream os\r
*/\r
-void canonicalPrintString(os,s)\r
-sexpOutputStream *os;\r
-sexpString *s;\r
+void canonicalPrintString(sexpOutputStream *os, sexpString *s)\r
{ sexpSimpleString *ph, *ss;\r
ph = sexpStringPresentationHint(s);\r
if (ph != NULL) \r
/* canonicalPrintList(os,list)\r
* Prints out the list "list" onto output stream os\r
*/\r
-void canonicalPrintList(os,list)\r
-sexpOutputStream *os;\r
-sexpList *list;\r
+void canonicalPrintList(sexpOutputStream *os, sexpList *list)\r
{ sexpIter *iter;\r
sexpObject *object;\r
varPutChar(os,'(');\r
* Prints out object on output stream os\r
* Note that this uses the common "type" field of lists and strings.\r
*/\r
-void canonicalPrintObject(os,object)\r
-sexpOutputStream *os;\r
-sexpObject *object;\r
+void canonicalPrintObject(sexpOutputStream *os, sexpObject *object)\r
{\r
if (isObjectString(object))\r
canonicalPrintString(os,(sexpString *)object);\r
/* *************/\r
/* Same as canonical, except all characters get put out as base 64 ones */\r
\r
-void base64PrintWholeObject(os,object)\r
-sexpOutputStream *os;\r
-sexpObject *object;\r
+void base64PrintWholeObject(sexpOutputStream *os, sexpObject *object)\r
{\r
changeOutputByteSize(os,8,BASE64);\r
varPutChar(os,'{');\r
* Returns TRUE if simple string ss can be printed as a token.\r
* Doesn't begin with a digit, and all characters are tokenchars.\r
*/\r
-int canPrintAsToken(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+int canPrintAsToken(sexpOutputStream *os, sexpSimpleString *ss)\r
{\r
int i;\r
octet *c;\r
* Prints out simple string ss as a token (assumes that this is OK).\r
* May run over max-column, but there is no fragmentation allowed...\r
*/\r
-void advancedPrintTokenSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void advancedPrintTokenSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{ int i;\r
long int len;\r
octet *c;\r
/* advancedLengthSimpleStringToken(ss)\r
* Returns length for printing simple string ss as a token \r
*/\r
-int advancedLengthSimpleStringToken(ss)\r
-sexpSimpleString *ss;\r
+int advancedLengthSimpleStringToken(sexpSimpleString *ss)\r
{ return(simpleStringLength(ss)); }\r
\r
\r
* Print out simple string ss on output stream os as verbatim string.\r
* Again, can't fragment string, so max-column is just a suggestion...\r
*/\r
-void advancedPrintVerbatimSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void advancedPrintVerbatimSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{ \r
long int len = simpleStringLength(ss);\r
long int i;\r
/* advancedLengthSimpleStringVerbatim(ss)\r
* Returns length for printing simple string ss in verbatim mode\r
*/\r
-int advancedLengthSimpleStringVerbatim(ss)\r
-sexpSimpleString *ss;\r
+int advancedLengthSimpleStringVerbatim(sexpSimpleString *ss)\r
{ long int len = simpleStringLength(ss);\r
int i = 1;\r
while (len > 9L) { i++; len = len / 10; }\r
/* advancedPrintBase64SimpleString(os,ss)\r
* Prints out simple string ss as a base64 value.\r
*/\r
-void advancedPrintBase64SimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void advancedPrintBase64SimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{\r
long int i,len;\r
octet *c = simpleStringString(ss);\r
/* advancedPrintHexSimpleString(os,ss)\r
* Prints out simple string ss as a hexadecimal value.\r
*/\r
-void advancedPrintHexSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void advancedPrintHexSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{\r
long int i,len;\r
octet *c = simpleStringString(ss);\r
/* advancedLengthSimpleStringHexadecimal(ss)\r
* Returns length for printing simple string ss in hexadecimal mode\r
*/\r
-int advancedLengthSimpleStringHexadecimal(ss)\r
-sexpSimpleString *ss;\r
+int advancedLengthSimpleStringHexadecimal(sexpSimpleString *ss)\r
{ long int len = simpleStringLength(ss);\r
return(1+2*len+1);\r
}\r
* Returns TRUE if simple string ss can be printed as a quoted string.\r
* Must have only tokenchars and blanks.\r
*/\r
-int canPrintAsQuotedString(ss)\r
-sexpSimpleString *ss;\r
+int canPrintAsQuotedString(sexpSimpleString *ss)\r
{\r
long int i, len;\r
octet *c = simpleStringString(ss);\r
* so no escape sequences need to be generated.\r
* May run over max-column, but there is no fragmentation allowed...\r
*/\r
-void advancedPrintQuotedStringSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void advancedPrintQuotedStringSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{ long int i;\r
long int len = simpleStringLength(ss);\r
octet *c = simpleStringString(ss);\r
/* advancedLengthSimpleStringQuotedString(ss)\r
* Returns length for printing simple string ss in quoted-string mode\r
*/\r
-int advancedLengthSimpleStringQuotedString(ss)\r
-sexpSimpleString *ss;\r
+int advancedLengthSimpleStringQuotedString(sexpSimpleString *ss)\r
{ long int len = simpleStringLength(ss);\r
return(1+len+1);\r
}\r
/* advancedPrintSimpleString(os,ss)\r
* Prints out simple string ss onto output stream ss\r
*/\r
-void advancedPrintSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+void advancedPrintSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{ long int len = simpleStringLength(ss);\r
if (canPrintAsToken(os,ss)) \r
advancedPrintTokenSimpleString(os,ss);\r
/* advancedPrintString(os,s)\r
* Prints out sexp string s onto output stream os\r
*/\r
-void advancedPrintString(os,s)\r
-sexpOutputStream *os;\r
-sexpString *s;\r
+void advancedPrintString(sexpOutputStream *os, sexpString *s)\r
{\r
sexpSimpleString *ph = sexpStringPresentationHint(s);\r
sexpSimpleString *ss = sexpStringString(s);\r
/* advancedLengthSimpleStringBase64(ss)\r
* Returns length for printing simple string ss as a base64 string\r
*/\r
-int advancedLengthSimpleStringBase64(ss)\r
-sexpSimpleString *ss;\r
+int advancedLengthSimpleStringBase64(sexpSimpleString *ss)\r
{ return(2+4*((simpleStringLength(ss)+2)/3)); }\r
\r
/* advancedLengthSimpleString(os,ss)\r
* Returns length of printed image of s\r
*/\r
-int advancedLengthSimpleString(os,ss)\r
-sexpOutputStream *os;\r
-sexpSimpleString *ss;\r
+int advancedLengthSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
{ long int len = simpleStringLength(ss);\r
if (canPrintAsToken(os,ss)) \r
return(advancedLengthSimpleStringToken(ss));\r
/* advancedLengthString(os,s)\r
* Returns length of printed image of string s\r
*/\r
-int advancedLengthString(os,s)\r
-sexpOutputStream *os;\r
-sexpString *s;\r
+int advancedLengthString(sexpOutputStream *os, sexpString *s)\r
{ int len = 0;\r
sexpSimpleString *ph = sexpStringPresentationHint(s);\r
sexpSimpleString *ss = sexpStringString(s);\r
/* advancedLengthList(os,list)\r
* Returns length of printed image of list given as iterator\r
*/\r
-int advancedLengthList(os,list)\r
-sexpOutputStream *os;\r
-sexpList *list;\r
+int advancedLengthList(sexpOutputStream *os, sexpList *list)\r
{ int len = 1; /* for left paren */\r
sexpIter *iter;\r
sexpObject *object;\r
* written out in "vertical" mode, with items of the list starting in\r
* the same column on successive lines.\r
*/\r
-void advancedPrintList(os,list)\r
-sexpOutputStream *os;\r
-sexpList *list;\r
+void advancedPrintList(sexpOutputStream *os, sexpList *list)\r
{ int vertical = FALSE;\r
int firstelement = TRUE;\r
sexpIter *iter;\r
/* advancedPrintObject(os,object)\r
* Prints out object on output stream os \r
*/\r
-void advancedPrintObject(os,object)\r
-sexpOutputStream *os;\r
-sexpObject *object;\r
+void advancedPrintObject(sexpOutputStream *os, sexpObject *object)\r
{\r
if (os->maxcolumn>0 && os->column>os->maxcolumn-4)\r
os->newLine(os,ADVANCED);\r
/* Function prototypes */\r
\r
/* sexp-basic */\r
-void ErrorMessage();\r
-void initializeMemory();\r
-char *sexpAlloc();\r
-sexpSimpleString *newSimpleString();\r
-long int simpleStringLength();\r
-octet *simpleStringString();\r
-sexpSimpleString *reallocateSimpleString();\r
-void appendCharToSimpleString();\r
-sexpString *newSexpString();\r
-sexpSimpleString *sexpStringPresentationHint();\r
-sexpSimpleString *sexpStringString();\r
-void setSexpStringPresentationHint();\r
-void setSexpStringString();\r
-void closeSexpString();\r
-sexpList *newSexpList();\r
-void sexpAddSexpListObject();\r
-void closeSexpList();\r
-sexpIter *sexpListIter();\r
-sexpIter *sexpIterNext();\r
-sexpObject *sexpIterObject();\r
-int isObjectString();\r
-int isObjectList();\r
+void ErrorMessage(int level, const char *msg, int c1, int c2)\r
+ /*@*/;\r
+void initializeMemory(void)\r
+ /*@*/;\r
+char *sexpAlloc(int n)\r
+ /*@*/;\r
+sexpSimpleString *newSimpleString(void)\r
+ /*@*/;\r
+long int simpleStringLength(sexpSimpleString *ss)\r
+ /*@*/;\r
+octet *simpleStringString(sexpSimpleString *ss)\r
+ /*@*/;\r
+sexpSimpleString *reallocateSimpleString(sexpSimpleString *ss)\r
+ /*@*/;\r
+void appendCharToSimpleString(int c, sexpSimpleString *ss)\r
+ /*@*/;\r
+sexpString *newSexpString(void)\r
+ /*@*/;\r
+sexpSimpleString *sexpStringPresentationHint(sexpString *s)\r
+ /*@*/;\r
+void setSexpStringPresentationHint(sexpString *s, sexpSimpleString *ss)\r
+ /*@*/;\r
+void setSexpStringString(sexpString *s, sexpSimpleString *ss)\r
+ /*@*/;\r
+sexpSimpleString *sexpStringString(sexpString *s)\r
+ /*@*/;\r
+void closeSexpString(sexpString *s)\r
+ /*@*/;\r
+sexpList *newSexpList(void)\r
+ /*@*/;\r
+void sexpAddSexpListObject(sexpList *list, sexpObject *object)\r
+ /*@*/;\r
+void closeSexpList(sexpList *list)\r
+ /*@*/;\r
+sexpIter *sexpListIter(sexpList *list)\r
+ /*@*/;\r
+sexpIter *sexpIterNext(sexpIter *iter)\r
+ /*@*/;\r
+sexpObject *sexpIterObject(sexpIter *iter)\r
+ /*@*/;\r
+int isObjectString(sexpObject *object)\r
+ /*@*/;\r
+int isObjectList(sexpObject *object)\r
+ /*@*/;\r
\r
/* sexp-input */\r
-void initializeCharacterTables();\r
-int isWhiteSpace();\r
-int isDecDigit();\r
-int isHexDigit();\r
-int isBase64Digit();\r
-int isTokenChar();\r
-int isAlpha();\r
-void changeInputByteSize();\r
-void getChar();\r
-sexpInputStream *newSexpInputStream();\r
-void skipWhiteSpace();\r
-void skipChar();\r
-void scanToken();\r
-sexpObject *scanToEOF();\r
-unsigned long int scanDecimal();\r
-void scanVerbatimString();\r
-void scanQuotedString();\r
-void scanHexString();\r
-void scanBase64String();\r
-sexpSimpleString *scanSimpleString();\r
-sexpString *scanString();\r
-sexpList *scanList();\r
-sexpObject *scanObject();\r
+void initializeCharacterTables(void)\r
+ /*@*/;\r
+int isWhiteSpace(int c)\r
+ /*@*/;\r
+int isDecDigit(int c)\r
+ /*@*/;\r
+int isHexDigit(int c)\r
+ /*@*/;\r
+int isBase64Digit(int c)\r
+ /*@*/;\r
+int isTokenChar(int c)\r
+ /*@*/;\r
+int isAlpha(int c)\r
+ /*@*/;\r
+void changeInputByteSize(sexpInputStream *is, int newByteSize)\r
+ /*@*/;\r
+void getChar(sexpInputStream *is)\r
+ /*@*/;\r
+sexpInputStream *newSexpInputStream(void)\r
+ /*@*/;\r
+void skipWhiteSpace(sexpInputStream *is)\r
+ /*@*/;\r
+void skipChar(sexpInputStream *is, int c)\r
+ /*@*/;\r
+void scanToken(sexpInputStream *is, sexpSimpleString *ss)\r
+ /*@*/;\r
+sexpObject *scanToEOF(sexpInputStream *is)\r
+ /*@*/;\r
+unsigned long int scanDecimal(sexpInputStream *is)\r
+ /*@*/;\r
+void scanVerbatimString(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
+ /*@*/;\r
+void scanQuotedString(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
+ /*@*/;\r
+void scanHexString(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
+ /*@*/;\r
+void scanBase64String(sexpInputStream *is, sexpSimpleString *ss, long int length)\r
+ /*@*/;\r
+sexpSimpleString *scanSimpleString(sexpInputStream *is)\r
+ /*@*/;\r
+sexpString *scanString(sexpInputStream *is)\r
+ /*@*/;\r
+sexpList *scanList(sexpInputStream *is)\r
+ /*@*/;\r
+sexpObject *scanObject(sexpInputStream *is)\r
+ /*@*/;\r
\r
/* sexp-output */\r
-void putChar();\r
-void varPutChar();\r
-void changeOutputByteSize();\r
-void flushOutput();\r
-void newLine();\r
-sexpOutputStream *newSexpOutputStream();\r
-void printDecimal();\r
-void canonicalPrintVerbatimSimpleString();\r
-void canonicalPrintString();\r
-void canonicalPrintList();\r
-void canonicalPrintObject();\r
-void base64PrintWholeObject();\r
-int canPrintAsToken();\r
-int significantNibbles();\r
-void advancedPrintTokenSimpleString();\r
-int advancedLengthSimpleStringToken();\r
-void advancedPrintVerbatimSimpleString();\r
-int advancedLengthSimpleStringVerbatim();\r
-void advancedPrintBase64SimpleString();\r
-void advancedPrintHexSimpleString();\r
-int canPrintAsQuotedString();\r
-void advancedPrintQuotedStringSimpleString();\r
-void advancedPrintSimpleString();\r
-void advancedPrintString();\r
-int advancedLengthSimpleStringBase64();\r
-int advancedLengthSimpleString();\r
-int advancedLengthString();\r
-int advancedLengthList();\r
-void advancedPrintList();\r
-void advancedPrintObject();\r
+void putChar(sexpOutputStream *os, int c)\r
+ /*@*/;\r
+void varPutChar(sexpOutputStream *os, int c)\r
+ /*@*/;\r
+void changeOutputByteSize(sexpOutputStream *os, int newByteSize, int mode)\r
+ /*@*/;\r
+void flushOutput(sexpOutputStream * os)\r
+ /*@*/;\r
+void newLine(sexpOutputStream *os, int mode)\r
+ /*@*/;\r
+sexpOutputStream *newSexpOutputStream(void)\r
+ /*@*/;\r
+void printDecimal(sexpOutputStream *os, long int n)\r
+ /*@*/;\r
+void canonicalPrintVerbatimSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+void canonicalPrintString(sexpOutputStream *os, sexpString *s)\r
+ /*@*/;\r
+void canonicalPrintList(sexpOutputStream *os, sexpList *list)\r
+ /*@*/;\r
+void canonicalPrintObject(sexpOutputStream *os, sexpObject *object)\r
+ /*@*/;\r
+void base64PrintWholeObject(sexpOutputStream *os, sexpObject *object)\r
+ /*@*/;\r
+int canPrintAsToken(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintTokenSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+int advancedLengthSimpleStringToken(sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintVerbatimSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+int advancedLengthSimpleStringVerbatim(sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintBase64SimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintHexSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+int advancedLengthSimpleStringHexadecimal(sexpSimpleString *ss)\r
+ /*@*/;\r
+int canPrintAsQuotedString(sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintQuotedStringSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+int advancedLengthSimpleStringQuotedString(sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+void advancedPrintString(sexpOutputStream *os, sexpString *s)\r
+ /*@*/;\r
+int advancedLengthSimpleStringBase64(sexpSimpleString *ss)\r
+ /*@*/;\r
+int advancedLengthSimpleString(sexpOutputStream *os, sexpSimpleString *ss)\r
+ /*@*/;\r
+int advancedLengthString(sexpOutputStream *os, sexpString *s)\r
+ /*@*/;\r
+int advancedLengthList(sexpOutputStream *os, sexpList *list)\r
+ /*@*/;\r
+void advancedPrintList(sexpOutputStream *os, sexpList *list)\r
+ /*@*/;\r
+void advancedPrintObject(sexpOutputStream *os, sexpObject *object)\r
+ /*@*/;\r
projects / platform / upstream / rpm.git / commitdiff